/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = 'central';
  @endpointMap = {
    cn-hangzhou = 'holowatcher.cn-hangzhou.aliyuncs.com',
  };

  checkConfig(config);
  @endpoint = getEndpoint('holowatcher', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model BaseRequest {
  requestId?: readable(name='RequestId', description='RequestId'),
}

model FloorPlan {
  angle?: long(name='Angle', description='angle'),
  imgHeight?: long(name='ImgHeight', description='imgHeight'),
  imgWidth?: long(name='ImgWidth', description='imgWidth'),
  scale?: long(name='Scale', description='scale'),
  translationX?: long(name='TranslationX', description='translationX'),
  translationY?: long(name='TranslationY', description='translationY'),
}

model ActivateUserRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  userId?: long(name='UserId'),
}

model ActivateUserResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: string(name='Success'),
}

model ActivateUserResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ActivateUserResponseBody(name='body'),
}

async function activateUserWithOptions(request: ActivateUserRequest, runtime: Util.RuntimeOptions): ActivateUserResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.userId)) {
    query['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ActivateUser',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function activateUser(request: ActivateUserRequest): ActivateUserResponse {
  var runtime = new Util.RuntimeOptions{};
  return activateUserWithOptions(request, runtime);
}

model AddQRCodeRequest {
  datasetId?: long(name='DatasetId', description='datasetId'),
  tag?: string(name='Tag', description='tag'),
}

model AddQRCodeResponseBody = {
  data?: string(name='Data', description='data'),
  error?: string(name='Error', description='error'),
  msgCode?: string(name='MsgCode', description='msgCode'),
  msgInfo?: string(name='MsgInfo', description='msgInfo'),
  requestId?: string(name='RequestId', description='traceId'),
  success?: boolean(name='Success', description='success'),
}

model AddQRCodeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AddQRCodeResponseBody(name='body'),
}

async function addQRCodeWithOptions(request: AddQRCodeRequest, runtime: Util.RuntimeOptions): AddQRCodeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.tag)) {
    query['Tag'] = request.tag;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddQRCode',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function addQRCode(request: AddQRCodeRequest): AddQRCodeResponse {
  var runtime = new Util.RuntimeOptions{};
  return addQRCodeWithOptions(request, runtime);
}

model AlgorithmCallBackRequest {
  fileUrl?: string(name='FileUrl', description='模型文件'),
  requestNumber?: string(name='RequestNumber', description='请求编号'),
}

model AlgorithmCallBackResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  result?: {
    isSuccess?: boolean(name='IsSuccess'),
  }(name='Result'),
}

model AlgorithmCallBackResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AlgorithmCallBackResponseBody(name='body'),
}

async function algorithmCallBackWithOptions(request: AlgorithmCallBackRequest, runtime: Util.RuntimeOptions): AlgorithmCallBackResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.fileUrl)) {
    body['FileUrl'] = request.fileUrl;
  }
  if (!Util.isUnset(request.requestNumber)) {
    body['RequestNumber'] = request.requestNumber;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'AlgorithmCallBack',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function algorithmCallBack(request: AlgorithmCallBackRequest): AlgorithmCallBackResponse {
  var runtime = new Util.RuntimeOptions{};
  return algorithmCallBackWithOptions(request, runtime);
}

model AlgorithmCreateBuildRequest {
  gender?: string(name='Gender'),
  image?: string(name='Image'),
}

model AlgorithmCreateBuildResponseBody = {
  content?: {
    code?: string(name='Code'),
    codeMsg?: string(name='CodeMsg'),
    requestNumber?: string(name='RequestNumber'),
  }(name='Content'),
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: boolean(name='Success'),
}

model AlgorithmCreateBuildResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AlgorithmCreateBuildResponseBody(name='body'),
}

async function algorithmCreateBuildWithOptions(request: AlgorithmCreateBuildRequest, runtime: Util.RuntimeOptions): AlgorithmCreateBuildResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.gender)) {
    body['Gender'] = request.gender;
  }
  if (!Util.isUnset(request.image)) {
    body['Image'] = request.image;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'AlgorithmCreateBuild',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function algorithmCreateBuild(request: AlgorithmCreateBuildRequest): AlgorithmCreateBuildResponse {
  var runtime = new Util.RuntimeOptions{};
  return algorithmCreateBuildWithOptions(request, runtime);
}

model AlgorithmQueryModelRequest {
  requestNumber?: string(name='RequestNumber'),
}

model AlgorithmQueryModelResponseBody = {
  content?: {
    code?: string(name='Code'),
    codeMsg?: string(name='CodeMsg'),
    fileUrl?: string(name='FileUrl'),
  }(name='Content'),
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: boolean(name='Success'),
}

model AlgorithmQueryModelResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AlgorithmQueryModelResponseBody(name='body'),
}

async function algorithmQueryModelWithOptions(request: AlgorithmQueryModelRequest, runtime: Util.RuntimeOptions): AlgorithmQueryModelResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.requestNumber)) {
    body['RequestNumber'] = request.requestNumber;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'AlgorithmQueryModel',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function algorithmQueryModel(request: AlgorithmQueryModelRequest): AlgorithmQueryModelResponse {
  var runtime = new Util.RuntimeOptions{};
  return algorithmQueryModelWithOptions(request, runtime);
}

model AliyunJwtCreateCommonRequest {
  aliyunAccountName?: string(name='AliyunAccountName'),
  aliyunUid?: string(name='AliyunUid'),
  aliyunUidType?: string(name='AliyunUidType'),
  parentUid?: string(name='ParentUid'),
  ticket?: string(name='Ticket'),
}

model AliyunJwtCreateCommonResponseBody = {
  aliyunJwt?: string(name='AliyunJwt'),
  errorMessage?: string(name='ErrorMessage'),
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: string(name='Success'),
}

model AliyunJwtCreateCommonResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AliyunJwtCreateCommonResponseBody(name='body'),
}

async function aliyunJwtCreateCommonWithOptions(request: AliyunJwtCreateCommonRequest, runtime: Util.RuntimeOptions): AliyunJwtCreateCommonResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunAccountName)) {
    query['AliyunAccountName'] = request.aliyunAccountName;
  }
  if (!Util.isUnset(request.aliyunUid)) {
    query['AliyunUid'] = request.aliyunUid;
  }
  if (!Util.isUnset(request.aliyunUidType)) {
    query['AliyunUidType'] = request.aliyunUidType;
  }
  if (!Util.isUnset(request.parentUid)) {
    query['ParentUid'] = request.parentUid;
  }
  if (!Util.isUnset(request.ticket)) {
    query['Ticket'] = request.ticket;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AliyunJwtCreateCommon',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function aliyunJwtCreateCommon(request: AliyunJwtCreateCommonRequest): AliyunJwtCreateCommonResponse {
  var runtime = new Util.RuntimeOptions{};
  return aliyunJwtCreateCommonWithOptions(request, runtime);
}

model AliyunMainJwtCreateRequest {
  aliyunUid?: string(name='AliyunUid'),
  aliyunUidType?: string(name='AliyunUidType'),
}

model AliyunMainJwtCreateResponseBody = {
  aliyunJwt?: string(name='AliyunJwt'),
  errorMessage?: string(name='ErrorMessage'),
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: string(name='Success'),
}

model AliyunMainJwtCreateResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AliyunMainJwtCreateResponseBody(name='body'),
}

async function aliyunMainJwtCreateWithOptions(request: AliyunMainJwtCreateRequest, runtime: Util.RuntimeOptions): AliyunMainJwtCreateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunUid)) {
    query['AliyunUid'] = request.aliyunUid;
  }
  if (!Util.isUnset(request.aliyunUidType)) {
    query['AliyunUidType'] = request.aliyunUidType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AliyunMainJwtCreate',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function aliyunMainJwtCreate(request: AliyunMainJwtCreateRequest): AliyunMainJwtCreateResponse {
  var runtime = new Util.RuntimeOptions{};
  return aliyunMainJwtCreateWithOptions(request, runtime);
}

model AliyunRamJwtCreateRequest {
  aliyunUidType?: string(name='AliyunUidType'),
  name?: string(name='Name'),
  parentUid?: string(name='ParentUid'),
}

model AliyunRamJwtCreateResponseBody = {
  aliyunJwt?: string(name='AliyunJwt'),
  errorMessage?: string(name='ErrorMessage'),
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: string(name='Success'),
}

model AliyunRamJwtCreateResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AliyunRamJwtCreateResponseBody(name='body'),
}

async function aliyunRamJwtCreateWithOptions(request: AliyunRamJwtCreateRequest, runtime: Util.RuntimeOptions): AliyunRamJwtCreateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunUidType)) {
    query['AliyunUidType'] = request.aliyunUidType;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.parentUid)) {
    query['ParentUid'] = request.parentUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AliyunRamJwtCreate',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function aliyunRamJwtCreate(request: AliyunRamJwtCreateRequest): AliyunRamJwtCreateResponse {
  var runtime = new Util.RuntimeOptions{};
  return aliyunRamJwtCreateWithOptions(request, runtime);
}

model AliyunTicketJwtCreateRequest {
  ticket?: string(name='Ticket'),
}

model AliyunTicketJwtCreateResponseBody = {
  aliyunJwt?: string(name='AliyunJwt'),
  errorMessage?: string(name='ErrorMessage'),
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: string(name='Success'),
}

model AliyunTicketJwtCreateResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AliyunTicketJwtCreateResponseBody(name='body'),
}

async function aliyunTicketJwtCreateWithOptions(request: AliyunTicketJwtCreateRequest, runtime: Util.RuntimeOptions): AliyunTicketJwtCreateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ticket)) {
    query['Ticket'] = request.ticket;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AliyunTicketJwtCreate',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function aliyunTicketJwtCreate(request: AliyunTicketJwtCreateRequest): AliyunTicketJwtCreateResponse {
  var runtime = new Util.RuntimeOptions{};
  return aliyunTicketJwtCreateWithOptions(request, runtime);
}

model AliyunUidWhiteListRequest {
  aliyunUid?: string(name='AliyunUid'),
}

model AliyunUidWhiteListResponseBody = {
  exist?: string(name='Exist'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model AliyunUidWhiteListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AliyunUidWhiteListResponseBody(name='body'),
}

async function aliyunUidWhiteListWithOptions(request: AliyunUidWhiteListRequest, runtime: Util.RuntimeOptions): AliyunUidWhiteListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunUid)) {
    query['AliyunUid'] = request.aliyunUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AliyunUidWhiteList',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function aliyunUidWhiteList(request: AliyunUidWhiteListRequest): AliyunUidWhiteListResponse {
  var runtime = new Util.RuntimeOptions{};
  return aliyunUidWhiteListWithOptions(request, runtime);
}

model AuthorizationSaveRequest {
  authorizationCode?: string(name='AuthorizationCode'),
  jwt?: string(name='Jwt'),
  phoneModel?: string(name='PhoneModel'),
  systemVersion?: string(name='SystemVersion'),
}

model AuthorizationSaveResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  reqeustId?: string(name='ReqeustId'),
  result?: map[string]any(name='Result', description='对象实例。'),
}

model AuthorizationSaveResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AuthorizationSaveResponseBody(name='body'),
}

async function authorizationSaveWithOptions(request: AuthorizationSaveRequest, runtime: Util.RuntimeOptions): AuthorizationSaveResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.authorizationCode)) {
    body['AuthorizationCode'] = request.authorizationCode;
  }
  if (!Util.isUnset(request.jwt)) {
    body['Jwt'] = request.jwt;
  }
  if (!Util.isUnset(request.phoneModel)) {
    body['PhoneModel'] = request.phoneModel;
  }
  if (!Util.isUnset(request.systemVersion)) {
    body['SystemVersion'] = request.systemVersion;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'AuthorizationSave',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function authorizationSave(request: AuthorizationSaveRequest): AuthorizationSaveResponse {
  var runtime = new Util.RuntimeOptions{};
  return authorizationSaveWithOptions(request, runtime);
}

model BimBuildModelRequest {
  taskId?: string(name='TaskId', description='任务Id'),
}

model BimBuildModelResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimBuildModelResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimBuildModelResponseBody(name='body'),
}

async function bimBuildModelWithOptions(request: BimBuildModelRequest, runtime: Util.RuntimeOptions): BimBuildModelResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimBuildModel',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimBuildModel(request: BimBuildModelRequest): BimBuildModelResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimBuildModelWithOptions(request, runtime);
}

model BimGetStsTokenRequest {
  taskId?: long(name='TaskId', description='任务id'),
}

model BimGetStsTokenResponseBody = {
  datas?: {
    accessKeyId?: string(name='AccessKeyId'),
    accessKeySecret?: string(name='AccessKeySecret'),
    expiration?: long(name='Expiration'),
    ossBucket?: string(name='OssBucket'),
    ossRegion?: string(name='OssRegion'),
    securityToken?: string(name='SecurityToken'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimGetStsTokenResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimGetStsTokenResponseBody(name='body'),
}

async function bimGetStsTokenWithOptions(request: BimGetStsTokenRequest, runtime: Util.RuntimeOptions): BimGetStsTokenResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimGetStsToken',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimGetStsToken(request: BimGetStsTokenRequest): BimGetStsTokenResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimGetStsTokenWithOptions(request, runtime);
}

model BimPreStepRequest {
  force?: boolean(name='Force'),
  taskId?: long(name='TaskId', description='任务id'),
}

model BimPreStepResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimPreStepResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimPreStepResponseBody(name='body'),
}

async function bimPreStepWithOptions(request: BimPreStepRequest, runtime: Util.RuntimeOptions): BimPreStepResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.force)) {
    query['Force'] = request.force;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimPreStep',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimPreStep(request: BimPreStepRequest): BimPreStepResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimPreStepWithOptions(request, runtime);
}

model BimProAgainBuildModeRequest {
  taskId?: long(name='TaskId'),
}

model BimProAgainBuildModeResponseBody = {
  datas?: {
    status?: string(name='Status'),
    taskId?: long(name='TaskId'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimProAgainBuildModeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimProAgainBuildModeResponseBody(name='body'),
}

async function bimProAgainBuildModeWithOptions(request: BimProAgainBuildModeRequest, runtime: Util.RuntimeOptions): BimProAgainBuildModeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimProAgainBuildMode',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimProAgainBuildMode(request: BimProAgainBuildModeRequest): BimProAgainBuildModeResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimProAgainBuildModeWithOptions(request, runtime);
}

model BimProjectDeleteFileRequest {
  id?: long(name='Id', description='源图纸id'),
}

model BimProjectDeleteFileResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimProjectDeleteFileResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimProjectDeleteFileResponseBody(name='body'),
}

async function bimProjectDeleteFileWithOptions(request: BimProjectDeleteFileRequest, runtime: Util.RuntimeOptions): BimProjectDeleteFileResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimProjectDeleteFile',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimProjectDeleteFile(request: BimProjectDeleteFileRequest): BimProjectDeleteFileResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimProjectDeleteFileWithOptions(request, runtime);
}

model BimProjectShareModelRequest {
  taskId?: long(name='TaskId'),
}

model BimProjectShareModelResponseBody = {
  datas?: {
    expireTime?: long(name='ExpireTime', description='失效时间'),
    shareId?: string(name='ShareId', description='分享id'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimProjectShareModelResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimProjectShareModelResponseBody(name='body'),
}

async function bimProjectShareModelWithOptions(request: BimProjectShareModelRequest, runtime: Util.RuntimeOptions): BimProjectShareModelResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimProjectShareModel',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimProjectShareModel(request: BimProjectShareModelRequest): BimProjectShareModelResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimProjectShareModelWithOptions(request, runtime);
}

model BimRetryTransRequest {
  taskId?: long(name='TaskId'),
}

model BimRetryTransResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimRetryTransResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimRetryTransResponseBody(name='body'),
}

async function bimRetryTransWithOptions(request: BimRetryTransRequest, runtime: Util.RuntimeOptions): BimRetryTransResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimRetryTrans',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimRetryTrans(request: BimRetryTransRequest): BimRetryTransResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimRetryTransWithOptions(request, runtime);
}

model BimStandardAutoSalbInfoRequest {
  standardId?: long(name='StandardId', description='标准图纸id'),
  taskId?: long(name='TaskId', description='任务id'),
}

model BimStandardAutoSalbInfoResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimStandardAutoSalbInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimStandardAutoSalbInfoResponseBody(name='body'),
}

async function bimStandardAutoSalbInfoWithOptions(request: BimStandardAutoSalbInfoRequest, runtime: Util.RuntimeOptions): BimStandardAutoSalbInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.standardId)) {
    query['StandardId'] = request.standardId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimStandardAutoSalbInfo',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimStandardAutoSalbInfo(request: BimStandardAutoSalbInfoRequest): BimStandardAutoSalbInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimStandardAutoSalbInfoWithOptions(request, runtime);
}

model BimStandardDetailRequest {
  standardId?: string(name='StandardId', description='标准图纸id'),
  taskId?: long(name='TaskId', description='任务id'),
}

model BimStandardDetailResponseBody = {
  datas?: {
    config?: map[string]any(name='Config', description='门窗表配置'),
    id?: long(name='Id', description='门窗表图纸id'),
    status?: long(name='Status', description='门窗表图纸状态'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimStandardDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimStandardDetailResponseBody(name='body'),
}

async function bimStandardDetailWithOptions(request: BimStandardDetailRequest, runtime: Util.RuntimeOptions): BimStandardDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.standardId)) {
    query['StandardId'] = request.standardId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimStandardDetail',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimStandardDetail(request: BimStandardDetailRequest): BimStandardDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimStandardDetailWithOptions(request, runtime);
}

model BimStandardElevationRequest {
  standardId?: long(name='StandardId', description='标准图纸id'),
  taskId?: long(name='TaskId', description='任务id'),
}

model BimStandardElevationResponseBody = {
  datas?: {
    config?: map[string]any(name='Config', description='立面配置信息'),
    id?: long(name='Id', description='立面标准图纸id'),
    status?: long(name='Status', description='立面标准图纸状态'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimStandardElevationResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimStandardElevationResponseBody(name='body'),
}

async function bimStandardElevationWithOptions(request: BimStandardElevationRequest, runtime: Util.RuntimeOptions): BimStandardElevationResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.standardId)) {
    query['StandardId'] = request.standardId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimStandardElevation',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimStandardElevation(request: BimStandardElevationRequest): BimStandardElevationResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimStandardElevationWithOptions(request, runtime);
}

model BimTransModelRequest {
  taskId?: long(name='TaskId', description='任务Id(项目id)'),
  type?: string(name='Type', description='转换文件类型'),
}

model BimTransModelResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimTransModelResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimTransModelResponseBody(name='body'),
}

async function bimTransModelWithOptions(request: BimTransModelRequest, runtime: Util.RuntimeOptions): BimTransModelResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimTransModel',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimTransModel(request: BimTransModelRequest): BimTransModelResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimTransModelWithOptions(request, runtime);
}

model BimTransModelStatusRequest {
  ids?: [ long ](name='Ids', description='转换图纸集合'),
}

model BimTransModelStatusShrinkRequest {
  idsShrink?: string(name='Ids', description='转换图纸集合'),
}

model BimTransModelStatusResponseBody = {
  datas?: [ 
    {
      id?: long(name='Id', description='转换模型id'),
      status?: long(name='Status', description='转换模型状态'),
    }
  ](name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimTransModelStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimTransModelStatusResponseBody(name='body'),
}

async function bimTransModelStatusWithOptions(tmpReq: BimTransModelStatusRequest, runtime: Util.RuntimeOptions): BimTransModelStatusResponse {
  Util.validateModel(tmpReq);
  var request = new BimTransModelStatusShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.ids)) {
    request.idsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.ids, 'Ids', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.idsShrink)) {
    query['Ids'] = request.idsShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimTransModelStatus',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimTransModelStatus(request: BimTransModelStatusRequest): BimTransModelStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimTransModelStatusWithOptions(request, runtime);
}

model BimUpdateProjectRequest {
  component?: [  map[string]any ](name='Component'),
  id?: long(name='Id'),
  name?: string(name='Name', description='项目名'),
  remarks?: string(name='Remarks', description='备注'),
  type?: string(name='Type', description='类型'),
}

model BimUpdateProjectShrinkRequest {
  componentShrink?: string(name='Component'),
  id?: long(name='Id'),
  name?: string(name='Name', description='项目名'),
  remarks?: string(name='Remarks', description='备注'),
  type?: string(name='Type', description='类型'),
}

model BimUpdateProjectResponseBody = {
  datas?: {
    component?: [  map[string]any ](name='Component', description='模型构件'),
    id?: long(name='Id', description='任务id(项目id)'),
    modelingStatus?: long(name='ModelingStatus'),
    name?: string(name='Name'),
    phase?: string(name='Phase', description='阶段'),
    remarks?: string(name='Remarks'),
    type?: string(name='Type'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BimUpdateProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BimUpdateProjectResponseBody(name='body'),
}

async function bimUpdateProjectWithOptions(tmpReq: BimUpdateProjectRequest, runtime: Util.RuntimeOptions): BimUpdateProjectResponse {
  Util.validateModel(tmpReq);
  var request = new BimUpdateProjectShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.component)) {
    request.componentShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.component, 'Component', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.componentShrink)) {
    query['Component'] = request.componentShrink;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.remarks)) {
    query['Remarks'] = request.remarks;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BimUpdateProject',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bimUpdateProject(request: BimUpdateProjectRequest): BimUpdateProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return bimUpdateProjectWithOptions(request, runtime);
}

model BindProjectsRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model BindProjectsResponseBody = {
  data?: map[string]string(name='Data'),
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: boolean(name='Success'),
}

model BindProjectsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BindProjectsResponseBody(name='body'),
}

async function bindProjectsWithOptions(request: BindProjectsRequest, runtime: Util.RuntimeOptions): BindProjectsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BindProjects',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bindProjects(request: BindProjectsRequest): BindProjectsResponse {
  var runtime = new Util.RuntimeOptions{};
  return bindProjectsWithOptions(request, runtime);
}

model CheckImageRequest {
  imagePath?: string(name='ImagePath'),
}

model CheckImageResponseBody = {
  data?: map[string]any(name='Data'),
  error?: string(name='Error'),
  msgCode?: string(name='MsgCode'),
  msgInfo?: string(name='MsgInfo'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CheckImageResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CheckImageResponseBody(name='body'),
}

async function checkImageWithOptions(request: CheckImageRequest, runtime: Util.RuntimeOptions): CheckImageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.imagePath)) {
    query['ImagePath'] = request.imagePath;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CheckImage',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function checkImage(request: CheckImageRequest): CheckImageResponse {
  var runtime = new Util.RuntimeOptions{};
  return checkImageWithOptions(request, runtime);
}

model CommonRequestRequest {
  api?: string(name='Api', description='A short description of struct'),
  bizOrderNo?: string(name='BizOrderNo'),
  params?: string(name='Params'),
  userId?: string(name='UserId'),
  userType?: string(name='UserType'),
}

model CommonRequestResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  requestId?: string(name='RequestId'),
  resultObj?: string(name='ResultObj'),
  retry?: boolean(name='Retry'),
  success?: boolean(name='Success'),
  traceId?: string(name='TraceId', description='Id of the request'),
}

model CommonRequestResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CommonRequestResponseBody(name='body'),
}

async function commonRequestWithOptions(request: CommonRequestRequest, runtime: Util.RuntimeOptions): CommonRequestResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.api)) {
    query['Api'] = request.api;
  }
  if (!Util.isUnset(request.bizOrderNo)) {
    query['BizOrderNo'] = request.bizOrderNo;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  if (!Util.isUnset(request.userId)) {
    query['UserId'] = request.userId;
  }
  if (!Util.isUnset(request.userType)) {
    query['UserType'] = request.userType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CommonRequest',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function commonRequest(request: CommonRequestRequest): CommonRequestResponse {
  var runtime = new Util.RuntimeOptions{};
  return commonRequestWithOptions(request, runtime);
}

model CompanyActivateOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  id?: string(name='Id'),
}

model CompanyActivateOneResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: string(name='Success'),
}

model CompanyActivateOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CompanyActivateOneResponseBody(name='body'),
}

async function companyActivateOneWithOptions(request: CompanyActivateOneRequest, runtime: Util.RuntimeOptions): CompanyActivateOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CompanyActivateOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function companyActivateOne(request: CompanyActivateOneRequest): CompanyActivateOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return companyActivateOneWithOptions(request, runtime);
}

model CompanyAndMainUserCreateRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  companyParams?: string(name='CompanyParams'),
  userParams?: string(name='UserParams'),
}

model CompanyAndMainUserCreateResponseBody = {
  company?: {
    contactPerson?: string(name='ContactPerson'),
    extraInfo?: {
      extInfoMap?: string(name='ExtInfoMap'),
      isvTypeEnumList?: [ string ](name='IsvTypeEnumList'),
      supportTypeEnumList?: [ string ](name='SupportTypeEnumList'),
    }(name='ExtraInfo'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    id?: string(name='Id'),
    name?: string(name='Name'),
    phone?: string(name='Phone'),
    status?: string(name='Status'),
  }(name='Company'),
  main?: {
    aliyunUid?: string(name='AliyunUid'),
    aliyunUidType?: string(name='AliyunUidType'),
    companyId?: long(name='CompanyId'),
    companyName?: string(name='CompanyName'),
    email?: string(name='Email'),
    ext1?: string(name='Ext1'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    id?: long(name='Id'),
    name?: string(name='Name'),
    phone?: string(name='Phone'),
    status?: string(name='Status'),
  }(name='Main'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model CompanyAndMainUserCreateResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CompanyAndMainUserCreateResponseBody(name='body'),
}

async function companyAndMainUserCreateWithOptions(request: CompanyAndMainUserCreateRequest, runtime: Util.RuntimeOptions): CompanyAndMainUserCreateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.companyParams)) {
    query['CompanyParams'] = request.companyParams;
  }
  if (!Util.isUnset(request.userParams)) {
    query['UserParams'] = request.userParams;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CompanyAndMainUserCreate',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function companyAndMainUserCreate(request: CompanyAndMainUserCreateRequest): CompanyAndMainUserCreateResponse {
  var runtime = new Util.RuntimeOptions{};
  return companyAndMainUserCreateWithOptions(request, runtime);
}

model CompanyCreateOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model CompanyCreateOneResponseBody = {
  contactPerson?: string(name='ContactPerson'),
  extraInfo?: {
    extInfoMap?: string(name='ExtInfoMap'),
    isvTypeEnumList?: [ string ](name='IsvTypeEnumList'),
    supportTypeEnumList?: [ string ](name='SupportTypeEnumList'),
  }(name='ExtraInfo'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  name?: string(name='Name'),
  phone?: string(name='Phone'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model CompanyCreateOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CompanyCreateOneResponseBody(name='body'),
}

async function companyCreateOneWithOptions(request: CompanyCreateOneRequest, runtime: Util.RuntimeOptions): CompanyCreateOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CompanyCreateOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function companyCreateOne(request: CompanyCreateOneRequest): CompanyCreateOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return companyCreateOneWithOptions(request, runtime);
}

model CompanyDisableOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  id?: long(name='Id'),
}

model CompanyDisableOneResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: string(name='Success'),
}

model CompanyDisableOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CompanyDisableOneResponseBody(name='body'),
}

async function companyDisableOneWithOptions(request: CompanyDisableOneRequest, runtime: Util.RuntimeOptions): CompanyDisableOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CompanyDisableOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function companyDisableOne(request: CompanyDisableOneRequest): CompanyDisableOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return companyDisableOneWithOptions(request, runtime);
}

model CompanyFindAllRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model CompanyFindAllResponseBody = {
  content?: [ 
    {
      accountNums?: string(name='AccountNums'),
      aliyunUid?: string(name='AliyunUid'),
      contactPerson?: string(name='ContactPerson'),
      extraInfo?: {
        extInfoMap?: string(name='ExtInfoMap'),
        isvTypeEnumList?: [ string ](name='IsvTypeEnumList'),
        supportTypeEnumList?: [ string ](name='SupportTypeEnumList'),
      }(name='ExtraInfo'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      phone?: string(name='Phone'),
      status?: string(name='Status'),
    }
  ](name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: boolean(name='Last'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId', description='Id of the request'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model CompanyFindAllResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CompanyFindAllResponseBody(name='body'),
}

async function companyFindAllWithOptions(request: CompanyFindAllRequest, runtime: Util.RuntimeOptions): CompanyFindAllResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CompanyFindAll',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function companyFindAll(request: CompanyFindAllRequest): CompanyFindAllResponse {
  var runtime = new Util.RuntimeOptions{};
  return companyFindAllWithOptions(request, runtime);
}

model CompanyFindByIsvTypeRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  isvType?: string(name='IsvType'),
}

model CompanyFindByIsvTypeResponseBody = {
  data?: [ 
    {
      aliyunUid?: string(name='AliyunUid'),
      contactPerson?: string(name='ContactPerson'),
      extraInfo?: {
        extInfoMap?: string(name='ExtInfoMap'),
        isvTypeEnumList?: [ string ](name='IsvTypeEnumList'),
        supportTypeEnumList?: [ string ](name='SupportTypeEnumList'),
      }(name='ExtraInfo'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      phone?: string(name='Phone'),
      status?: string(name='Status'),
    }
  ](name='Data'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model CompanyFindByIsvTypeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CompanyFindByIsvTypeResponseBody(name='body'),
}

async function companyFindByIsvTypeWithOptions(request: CompanyFindByIsvTypeRequest, runtime: Util.RuntimeOptions): CompanyFindByIsvTypeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.isvType)) {
    query['IsvType'] = request.isvType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CompanyFindByIsvType',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function companyFindByIsvType(request: CompanyFindByIsvTypeRequest): CompanyFindByIsvTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return companyFindByIsvTypeWithOptions(request, runtime);
}

model CompanyFindOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  companyId?: long(name='CompanyId'),
}

model CompanyFindOneResponseBody = {
  contactPerson?: string(name='ContactPerson'),
  extraInfo?: {
    extInfoMap?: string(name='ExtInfoMap'),
    isvTypeEnumList?: [ string ](name='IsvTypeEnumList'),
    supportTypeEnumList?: [ string ](name='SupportTypeEnumList'),
  }(name='ExtraInfo'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  name?: string(name='Name'),
  phone?: string(name='Phone'),
  requestId?: string(name='RequestId', description='Id of the request'),
  status?: string(name='Status'),
}

model CompanyFindOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CompanyFindOneResponseBody(name='body'),
}

async function companyFindOneWithOptions(request: CompanyFindOneRequest, runtime: Util.RuntimeOptions): CompanyFindOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.companyId)) {
    query['CompanyId'] = request.companyId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CompanyFindOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function companyFindOne(request: CompanyFindOneRequest): CompanyFindOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return companyFindOneWithOptions(request, runtime);
}

model CompanyListByConditionRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  customSeeSelf?: boolean(name='CustomSeeSelf'),
  isvType?: string(name='IsvType'),
  supportType?: string(name='SupportType'),
}

model CompanyListByConditionResponseBody = {
  data?: [ 
    {
      contactPerson?: string(name='ContactPerson'),
      extraInfo?: {
        extInfoMap?: string(name='ExtInfoMap'),
        isvTypeEnumList?: [ string ](name='IsvTypeEnumList'),
        supportTypeEnumList?: [ string ](name='SupportTypeEnumList'),
      }(name='ExtraInfo'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      phone?: string(name='Phone'),
      status?: string(name='Status'),
    }
  ](name='Data'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model CompanyListByConditionResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CompanyListByConditionResponseBody(name='body'),
}

async function companyListByConditionWithOptions(request: CompanyListByConditionRequest, runtime: Util.RuntimeOptions): CompanyListByConditionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.customSeeSelf)) {
    query['CustomSeeSelf'] = request.customSeeSelf;
  }
  if (!Util.isUnset(request.isvType)) {
    query['IsvType'] = request.isvType;
  }
  if (!Util.isUnset(request.supportType)) {
    query['SupportType'] = request.supportType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CompanyListByCondition',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function companyListByCondition(request: CompanyListByConditionRequest): CompanyListByConditionResponse {
  var runtime = new Util.RuntimeOptions{};
  return companyListByConditionWithOptions(request, runtime);
}

model CompanyUpdateOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model CompanyUpdateOneResponseBody = {
  contactPerson?: string(name='ContactPerson'),
  extraInfo?: {
    extInfoMap?: string(name='ExtInfoMap'),
    isvTypeEnumList?: [ string ](name='IsvTypeEnumList'),
    supportTypeEnumList?: [ string ](name='SupportTypeEnumList'),
  }(name='ExtraInfo'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  name?: string(name='Name'),
  phone?: string(name='Phone'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model CompanyUpdateOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CompanyUpdateOneResponseBody(name='body'),
}

async function companyUpdateOneWithOptions(request: CompanyUpdateOneRequest, runtime: Util.RuntimeOptions): CompanyUpdateOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CompanyUpdateOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function companyUpdateOne(request: CompanyUpdateOneRequest): CompanyUpdateOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return companyUpdateOneWithOptions(request, runtime);
}

model CreateBimProjectRequest {
  component?: [  map[string]any ](name='Component'),
  name?: string(name='Name', description='项目名'),
  remarks?: string(name='Remarks', description='备注'),
  type?: string(name='Type', description='类型'),
}

model CreateBimProjectShrinkRequest {
  componentShrink?: string(name='Component'),
  name?: string(name='Name', description='项目名'),
  remarks?: string(name='Remarks', description='备注'),
  type?: string(name='Type', description='类型'),
}

model CreateBimProjectResponseBody = {
  datas?: {
    component?: [  map[string]any ](name='Component', description='模型构件'),
    id?: map[string]any(name='Id', description='任务id(项目id)'),
    modelingStatus?: long(name='ModelingStatus'),
    name?: string(name='Name'),
    phase?: string(name='Phase', description='阶段'),
    remarks?: string(name='Remarks'),
    type?: string(name='Type'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateBimProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateBimProjectResponseBody(name='body'),
}

async function createBimProjectWithOptions(tmpReq: CreateBimProjectRequest, runtime: Util.RuntimeOptions): CreateBimProjectResponse {
  Util.validateModel(tmpReq);
  var request = new CreateBimProjectShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.component)) {
    request.componentShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.component, 'Component', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.componentShrink)) {
    query['Component'] = request.componentShrink;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.remarks)) {
    query['Remarks'] = request.remarks;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateBimProject',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createBimProject(request: CreateBimProjectRequest): CreateBimProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return createBimProjectWithOptions(request, runtime);
}

model CreateMainUserRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model CreateMainUserResponseBody = {
  companyId?: long(name='CompanyId'),
  companyName?: string(name='CompanyName'),
  email?: string(name='Email'),
  ext1?: string(name='Ext1'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  name?: string(name='Name'),
  phone?: string(name='Phone'),
  requestId?: string(name='RequestId', description='Id of the request'),
  status?: string(name='Status'),
}

model CreateMainUserResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateMainUserResponseBody(name='body'),
}

async function createMainUserWithOptions(request: CreateMainUserRequest, runtime: Util.RuntimeOptions): CreateMainUserResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateMainUser',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createMainUser(request: CreateMainUserRequest): CreateMainUserResponse {
  var runtime = new Util.RuntimeOptions{};
  return createMainUserWithOptions(request, runtime);
}

model CreateMaterialRequest {
  clientToken?: string(name='ClientToken'),
  name?: string(name='Name'),
  path?: string(name='Path'),
  type?: string(name='Type'),
  uuid?: string(name='Uuid'),
}

model CreateMaterialResponseBody = {
  data?: map[string]any(name='Data'),
  error?: string(name='Error'),
  msgCode?: string(name='MsgCode'),
  msgInfo?: string(name='MsgInfo'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateMaterialResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateMaterialResponseBody(name='body'),
}

async function createMaterialWithOptions(request: CreateMaterialRequest, runtime: Util.RuntimeOptions): CreateMaterialResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.path)) {
    query['Path'] = request.path;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.uuid)) {
    query['Uuid'] = request.uuid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateMaterial',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createMaterial(request: CreateMaterialRequest): CreateMaterialResponse {
  var runtime = new Util.RuntimeOptions{};
  return createMaterialWithOptions(request, runtime);
}

model CreateOrUpdateExtInfoRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  extInfo?: string(name='ExtInfo'),
  projectId?: string(name='ProjectId'),
}

model CreateOrUpdateExtInfoResponseBody = {
  ossSts?: string(name='OssSts'),
  pipelineStatus?: string(name='PipelineStatus'),
  projectId?: long(name='ProjectId'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model CreateOrUpdateExtInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateOrUpdateExtInfoResponseBody(name='body'),
}

async function createOrUpdateExtInfoWithOptions(request: CreateOrUpdateExtInfoRequest, runtime: Util.RuntimeOptions): CreateOrUpdateExtInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.extInfo)) {
    query['ExtInfo'] = request.extInfo;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateOrUpdateExtInfo',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createOrUpdateExtInfo(request: CreateOrUpdateExtInfoRequest): CreateOrUpdateExtInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return createOrUpdateExtInfoWithOptions(request, runtime);
}

model CreatePipelineNodeInstanceRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model CreatePipelineNodeInstanceResponseBody = {
  code?: string(name='Code'),
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  resultObj?: map[string]any(name='ResultObj'),
  success?: boolean(name='Success'),
}

model CreatePipelineNodeInstanceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreatePipelineNodeInstanceResponseBody(name='body'),
}

async function createPipelineNodeInstanceWithOptions(request: CreatePipelineNodeInstanceRequest, runtime: Util.RuntimeOptions): CreatePipelineNodeInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreatePipelineNodeInstance',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createPipelineNodeInstance(request: CreatePipelineNodeInstanceRequest): CreatePipelineNodeInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return createPipelineNodeInstanceWithOptions(request, runtime);
}

model CreateRamUserRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model CreateRamUserResponseBody = {
  companyId?: long(name='CompanyId'),
  email?: string(name='Email'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  name?: string(name='Name'),
  phone?: string(name='Phone'),
  requestId?: string(name='RequestId', description='Id of the request'),
  status?: string(name='Status'),
}

model CreateRamUserResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateRamUserResponseBody(name='body'),
}

async function createRamUserWithOptions(request: CreateRamUserRequest, runtime: Util.RuntimeOptions): CreateRamUserResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateRamUser',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createRamUser(request: CreateRamUserRequest): CreateRamUserResponse {
  var runtime = new Util.RuntimeOptions{};
  return createRamUserWithOptions(request, runtime);
}

model CustomCreateOrderRequest {
  itemType?: string(name='ItemType'),
  orderName?: string(name='OrderName'),
  orderPhotoContact?: string(name='OrderPhotoContact'),
  photoAddress?: string(name='PhotoAddress'),
  photoEnvironment?: string(name='PhotoEnvironment'),
  photoFloorNum?: long(name='PhotoFloorNum'),
}

model CustomCreateOrderResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: {
    cipherId?: string(name='CipherId'),
    cipherProjectId?: string(name='CipherProjectId'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    orderName?: string(name='OrderName'),
    orderState?: string(name='OrderState'),
  }(name='ResultObj'),
  success?: boolean(name='Success'),
}

model CustomCreateOrderResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CustomCreateOrderResponseBody(name='body'),
}

async function customCreateOrderWithOptions(request: CustomCreateOrderRequest, runtime: Util.RuntimeOptions): CustomCreateOrderResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.itemType)) {
    query['ItemType'] = request.itemType;
  }
  if (!Util.isUnset(request.orderName)) {
    query['OrderName'] = request.orderName;
  }
  if (!Util.isUnset(request.orderPhotoContact)) {
    query['OrderPhotoContact'] = request.orderPhotoContact;
  }
  if (!Util.isUnset(request.photoAddress)) {
    query['PhotoAddress'] = request.photoAddress;
  }
  if (!Util.isUnset(request.photoEnvironment)) {
    query['PhotoEnvironment'] = request.photoEnvironment;
  }
  if (!Util.isUnset(request.photoFloorNum)) {
    query['PhotoFloorNum'] = request.photoFloorNum;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CustomCreateOrder',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function customCreateOrder(request: CustomCreateOrderRequest): CustomCreateOrderResponse {
  var runtime = new Util.RuntimeOptions{};
  return customCreateOrderWithOptions(request, runtime);
}

model CustomFindOrderRequest {
  orderIdCipher?: string(name='OrderIdCipher'),
  orderName?: string(name='OrderName'),
  orderState?: string(name='OrderState'),
  page?: long(name='Page'),
  size?: long(name='Size'),
  sort?: string(name='Sort'),
}

model CustomFindOrderResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: {
    content?: [ 
      {
        cipherId?: string(name='CipherId'),
        cipherProjectId?: string(name='CipherProjectId'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        orderName?: string(name='OrderName'),
        orderState?: string(name='OrderState'),
      }
    ](name='Content'),
    size?: long(name='Size'),
    totalElements?: long(name='TotalElements'),
    totalPages?: long(name='TotalPages'),
  }(name='ResultObj'),
  success?: boolean(name='Success'),
}

model CustomFindOrderResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CustomFindOrderResponseBody(name='body'),
}

async function customFindOrderWithOptions(request: CustomFindOrderRequest, runtime: Util.RuntimeOptions): CustomFindOrderResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.orderIdCipher)) {
    query['OrderIdCipher'] = request.orderIdCipher;
  }
  if (!Util.isUnset(request.orderName)) {
    query['OrderName'] = request.orderName;
  }
  if (!Util.isUnset(request.orderState)) {
    query['OrderState'] = request.orderState;
  }
  if (!Util.isUnset(request.page)) {
    query['Page'] = request.page;
  }
  if (!Util.isUnset(request.size)) {
    query['Size'] = request.size;
  }
  if (!Util.isUnset(request.sort)) {
    query['Sort'] = request.sort;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CustomFindOrder',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function customFindOrder(request: CustomFindOrderRequest): CustomFindOrderResponse {
  var runtime = new Util.RuntimeOptions{};
  return customFindOrderWithOptions(request, runtime);
}

model CustomFindOrderStatusRequest {
  orderIdCipher?: string(name='OrderIdCipher'),
}

model CustomFindOrderStatusResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: {
    status?: string(name='Status'),
  }(name='ResultObj'),
  success?: boolean(name='Success'),
}

model CustomFindOrderStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CustomFindOrderStatusResponseBody(name='body'),
}

async function customFindOrderStatusWithOptions(request: CustomFindOrderStatusRequest, runtime: Util.RuntimeOptions): CustomFindOrderStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.orderIdCipher)) {
    query['OrderIdCipher'] = request.orderIdCipher;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CustomFindOrderStatus',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function customFindOrderStatus(request: CustomFindOrderStatusRequest): CustomFindOrderStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return customFindOrderStatusWithOptions(request, runtime);
}

model CustomGetCdnModelPathRequest {
  orderIdCipher?: string(name='OrderIdCipher'),
}

model CustomGetCdnModelPathResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: {
    path?: string(name='Path'),
  }(name='ResultObj'),
  success?: boolean(name='Success'),
}

model CustomGetCdnModelPathResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CustomGetCdnModelPathResponseBody(name='body'),
}

async function customGetCdnModelPathWithOptions(request: CustomGetCdnModelPathRequest, runtime: Util.RuntimeOptions): CustomGetCdnModelPathResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.orderIdCipher)) {
    query['OrderIdCipher'] = request.orderIdCipher;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CustomGetCdnModelPath',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function customGetCdnModelPath(request: CustomGetCdnModelPathRequest): CustomGetCdnModelPathResponse {
  var runtime = new Util.RuntimeOptions{};
  return customGetCdnModelPathWithOptions(request, runtime);
}

model DataStoreCredentialRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  type?: string(name='Type'),
}

model DataStoreCredentialResponseBody = {
  accessKeyId?: string(name='AccessKeyId'),
  accessKeySecret?: string(name='AccessKeySecret'),
  endpoint?: string(name='Endpoint'),
  expiration?: string(name='Expiration'),
  ossPath?: string(name='OssPath'),
  requestId?: string(name='RequestId', description='Id of the request'),
  securityToken?: string(name='SecurityToken'),
}

model DataStoreCredentialResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DataStoreCredentialResponseBody(name='body'),
}

async function dataStoreCredentialWithOptions(request: DataStoreCredentialRequest, runtime: Util.RuntimeOptions): DataStoreCredentialResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DataStoreCredential',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function dataStoreCredential(request: DataStoreCredentialRequest): DataStoreCredentialResponse {
  var runtime = new Util.RuntimeOptions{};
  return dataStoreCredentialWithOptions(request, runtime);
}

model DatasetConfigFindAllRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  datasetId?: long(name='DatasetId'),
  size?: long(name='Size'),
  sort?: string(name='Sort'),
  type?: string(name='Type'),
}

model DatasetConfigFindAllResponseBody = {
  content?: [ 
    {
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      gmtPublished?: string(name='GmtPublished'),
      id?: long(name='Id'),
      key?: string(name='Key'),
      tag?: string(name='Tag'),
      type?: string(name='Type'),
      value?: map[string]any(name='Value'),
    }
  ](name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: boolean(name='Last'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId', description='Id of the request'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model DatasetConfigFindAllResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetConfigFindAllResponseBody(name='body'),
}

async function datasetConfigFindAllWithOptions(request: DatasetConfigFindAllRequest, runtime: Util.RuntimeOptions): DatasetConfigFindAllResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.size)) {
    query['Size'] = request.size;
  }
  if (!Util.isUnset(request.sort)) {
    query['Sort'] = request.sort;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetConfigFindAll',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetConfigFindAll(request: DatasetConfigFindAllRequest): DatasetConfigFindAllResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetConfigFindAllWithOptions(request, runtime);
}

model DatasetConfigFindOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  datasetId?: long(name='DatasetId'),
  key?: string(name='Key'),
  type?: string(name='Type'),
}

model DatasetConfigFindOneResponseBody = {
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  gmtPublished?: string(name='GmtPublished'),
  id?: long(name='Id'),
  key?: string(name='Key'),
  requestId?: string(name='RequestId', description='Id of the request'),
  tag?: string(name='Tag'),
  type?: string(name='Type'),
  value?: map[string]any(name='Value'),
}

model DatasetConfigFindOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetConfigFindOneResponseBody(name='body'),
}

async function datasetConfigFindOneWithOptions(request: DatasetConfigFindOneRequest, runtime: Util.RuntimeOptions): DatasetConfigFindOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.key)) {
    query['Key'] = request.key;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetConfigFindOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetConfigFindOne(request: DatasetConfigFindOneRequest): DatasetConfigFindOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetConfigFindOneWithOptions(request, runtime);
}

model DatasetConfigUpdateOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  data?: string(name='Data'),
  datasetId?: string(name='DatasetId'),
  key?: string(name='Key'),
  type?: string(name='Type'),
}

model DatasetConfigUpdateOneResponseBody = {
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  gmtPublished?: string(name='GmtPublished'),
  id?: long(name='Id'),
  key?: string(name='Key'),
  requestId?: string(name='RequestId', description='Id of the request'),
  tag?: string(name='Tag'),
  type?: string(name='Type'),
  value?: map[string]any(name='Value'),
}

model DatasetConfigUpdateOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetConfigUpdateOneResponseBody(name='body'),
}

async function datasetConfigUpdateOneWithOptions(request: DatasetConfigUpdateOneRequest, runtime: Util.RuntimeOptions): DatasetConfigUpdateOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.data)) {
    query['Data'] = request.data;
  }
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.key)) {
    query['Key'] = request.key;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetConfigUpdateOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetConfigUpdateOne(request: DatasetConfigUpdateOneRequest): DatasetConfigUpdateOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetConfigUpdateOneWithOptions(request, runtime);
}

model DatasetCreateOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  body?: {
    bizType?: string(name='BizType'),
    note?: {
      description?: string(name='Description'),
      name?: string(name='Name'),
    }(name='Note'),
    typeId?: long(name='TypeId'),
  }(name='Body'),
  projectId?: long(name='ProjectId'),
}

model DatasetCreateOneResponseBody = {
  bizType?: string(name='BizType'),
  code?: string(name='Code'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  gmtPublished?: string(name='GmtPublished'),
  id?: long(name='Id'),
  message?: string(name='Message'),
  note?: {
    description?: string(name='Description'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    id?: long(name='Id'),
    name?: string(name='Name'),
  }(name='Note'),
  ossKey?: string(name='OssKey'),
  publishStatus?: string(name='PublishStatus'),
  requestId?: string(name='RequestId', description='Id of the request'),
  status?: string(name='Status'),
  typeId?: long(name='TypeId'),
}

model DatasetCreateOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetCreateOneResponseBody(name='body'),
}

async function datasetCreateOneWithOptions(request: DatasetCreateOneRequest, runtime: Util.RuntimeOptions): DatasetCreateOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.body)) {
    query['Body'] = request.body;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetCreateOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetCreateOne(request: DatasetCreateOneRequest): DatasetCreateOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetCreateOneWithOptions(request, runtime);
}

model DatasetDeteleOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  datasetId?: long(name='DatasetId'),
}

model DatasetDeteleOneResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model DatasetDeteleOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetDeteleOneResponseBody(name='body'),
}

async function datasetDeteleOneWithOptions(request: DatasetDeteleOneRequest, runtime: Util.RuntimeOptions): DatasetDeteleOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  var body : map[string]any= {};
  if (!Util.isUnset(request.datasetId)) {
    body['DatasetId'] = request.datasetId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DatasetDeteleOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetDeteleOne(request: DatasetDeteleOneRequest): DatasetDeteleOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetDeteleOneWithOptions(request, runtime);
}

model DatasetFindAllRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  bizType?: string(name='BizType'),
  noProject?: boolean(name='NoProject'),
  notProjectId?: long(name='NotProjectId'),
  note?: string(name='Note'),
  projectId?: long(name='ProjectId'),
  size?: long(name='Size'),
  sort?: string(name='Sort'),
  status?: string(name='Status'),
  typeId?: long(name='TypeId'),
}

model DatasetFindAllResponseBody = {
  code?: string(name='Code'),
  content?: [ 
    {
      bizType?: string(name='BizType'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      gmtPublished?: string(name='GmtPublished'),
      id?: long(name='Id'),
      note?: {
        description?: string(name='Description'),
        name?: string(name='Name'),
      }(name='Note'),
      ossKey?: string(name='OssKey'),
      publishStatus?: string(name='PublishStatus'),
      status?: string(name='Status'),
      typeId?: long(name='TypeId'),
    }
  ](name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: boolean(name='Last'),
  message?: string(name='Message'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId', description='Id of the request'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model DatasetFindAllResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetFindAllResponseBody(name='body'),
}

async function datasetFindAllWithOptions(request: DatasetFindAllRequest, runtime: Util.RuntimeOptions): DatasetFindAllResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.noProject)) {
    query['NoProject'] = request.noProject;
  }
  if (!Util.isUnset(request.notProjectId)) {
    query['NotProjectId'] = request.notProjectId;
  }
  if (!Util.isUnset(request.note)) {
    query['Note'] = request.note;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.size)) {
    query['Size'] = request.size;
  }
  if (!Util.isUnset(request.sort)) {
    query['Sort'] = request.sort;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  if (!Util.isUnset(request.typeId)) {
    query['TypeId'] = request.typeId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetFindAll',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetFindAll(request: DatasetFindAllRequest): DatasetFindAllResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetFindAllWithOptions(request, runtime);
}

model DatasetPublishPublishRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  datasetId?: long(name='DatasetId'),
  overwriteLatest?: boolean(name='OverwriteLatest'),
  projectId?: long(name='ProjectId'),
}

model DatasetPublishPublishResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request'),
  submit?: string(name='Submit'),
}

model DatasetPublishPublishResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetPublishPublishResponseBody(name='body'),
}

async function datasetPublishPublishWithOptions(request: DatasetPublishPublishRequest, runtime: Util.RuntimeOptions): DatasetPublishPublishResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.overwriteLatest)) {
    query['OverwriteLatest'] = request.overwriteLatest;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetPublishPublish',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetPublishPublish(request: DatasetPublishPublishRequest): DatasetPublishPublishResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetPublishPublishWithOptions(request, runtime);
}

model DatasetTypeFindAllRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  size?: long(name='Size'),
  sort?: string(name='Sort'),
}

model DatasetTypeFindAllResponseBody = {
  code?: string(name='Code'),
  content?: [ 
    {
      code?: string(name='Code'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      note?: string(name='Note'),
    }
  ](name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: boolean(name='Last'),
  message?: string(name='Message'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId', description='Id of the request'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model DatasetTypeFindAllResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetTypeFindAllResponseBody(name='body'),
}

async function datasetTypeFindAllWithOptions(request: DatasetTypeFindAllRequest, runtime: Util.RuntimeOptions): DatasetTypeFindAllResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.size)) {
    query['Size'] = request.size;
  }
  if (!Util.isUnset(request.sort)) {
    query['Sort'] = request.sort;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetTypeFindAll',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetTypeFindAll(request: DatasetTypeFindAllRequest): DatasetTypeFindAllResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetTypeFindAllWithOptions(request, runtime);
}

model DatasetUnbindProjectRequest {
  datasetId?: long(name='DatasetId'),
}

model DatasetUnbindProjectResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request'),
}

model DatasetUnbindProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetUnbindProjectResponseBody(name='body'),
}

async function datasetUnbindProjectWithOptions(request: DatasetUnbindProjectRequest, runtime: Util.RuntimeOptions): DatasetUnbindProjectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetUnbindProject',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetUnbindProject(request: DatasetUnbindProjectRequest): DatasetUnbindProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetUnbindProjectWithOptions(request, runtime);
}

model DatasetUpdateOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  bizType?: string(name='BizType'),
  datasetId?: long(name='DatasetId'),
  status?: string(name='Status'),
  typeId?: long(name='TypeId'),
}

model DatasetUpdateOneResponseBody = {
  bizType?: string(name='BizType'),
  code?: string(name='Code'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  gmtPublished?: string(name='GmtPublished'),
  id?: long(name='Id'),
  message?: string(name='Message'),
  note?: {
    description?: string(name='Description'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    id?: long(name='Id'),
    name?: string(name='Name'),
  }(name='Note'),
  ossKey?: string(name='OssKey'),
  publishStatus?: string(name='PublishStatus'),
  requestId?: string(name='RequestId', description='Id of the request'),
  status?: string(name='Status'),
  typeId?: long(name='TypeId'),
}

model DatasetUpdateOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetUpdateOneResponseBody(name='body'),
}

async function datasetUpdateOneWithOptions(request: DatasetUpdateOneRequest, runtime: Util.RuntimeOptions): DatasetUpdateOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  if (!Util.isUnset(request.typeId)) {
    query['TypeId'] = request.typeId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetUpdateOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetUpdateOne(request: DatasetUpdateOneRequest): DatasetUpdateOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetUpdateOneWithOptions(request, runtime);
}

model DatasetUploadCreateOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  datasetId?: long(name='DatasetId'),
  deviceKey?: string(name='DeviceKey'),
}

model DatasetUploadCreateOneResponseBody = {
  code?: string(name='Code'),
  datasetId?: long(name='DatasetId'),
  deviceKey?: string(name='DeviceKey'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  message?: string(name='Message'),
  progress?: long(name='Progress'),
  requestId?: string(name='RequestId', description='Id of the request'),
  status?: string(name='Status'),
}

model DatasetUploadCreateOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetUploadCreateOneResponseBody(name='body'),
}

async function datasetUploadCreateOneWithOptions(request: DatasetUploadCreateOneRequest, runtime: Util.RuntimeOptions): DatasetUploadCreateOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.deviceKey)) {
    query['DeviceKey'] = request.deviceKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetUploadCreateOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetUploadCreateOne(request: DatasetUploadCreateOneRequest): DatasetUploadCreateOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetUploadCreateOneWithOptions(request, runtime);
}

model DatasetUploadDeleteOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  datasetId?: long(name='DatasetId'),
  projectId?: long(name='ProjectId'),
  uploadId?: long(name='UploadId'),
}

model DatasetUploadDeleteOneResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model DatasetUploadDeleteOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetUploadDeleteOneResponseBody(name='body'),
}

async function datasetUploadDeleteOneWithOptions(request: DatasetUploadDeleteOneRequest, runtime: Util.RuntimeOptions): DatasetUploadDeleteOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.uploadId)) {
    query['UploadId'] = request.uploadId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetUploadDeleteOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetUploadDeleteOne(request: DatasetUploadDeleteOneRequest): DatasetUploadDeleteOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetUploadDeleteOneWithOptions(request, runtime);
}

model DatasetUploadDeleteOssFileRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  datasetId?: long(name='DatasetId'),
  uploadId?: long(name='UploadId'),
}

model DatasetUploadDeleteOssFileResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request'),
}

model DatasetUploadDeleteOssFileResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetUploadDeleteOssFileResponseBody(name='body'),
}

async function datasetUploadDeleteOssFileWithOptions(request: DatasetUploadDeleteOssFileRequest, runtime: Util.RuntimeOptions): DatasetUploadDeleteOssFileResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.uploadId)) {
    query['UploadId'] = request.uploadId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetUploadDeleteOssFile',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetUploadDeleteOssFile(request: DatasetUploadDeleteOssFileRequest): DatasetUploadDeleteOssFileResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetUploadDeleteOssFileWithOptions(request, runtime);
}

model DatasetUploadFindByDatasetIdRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  datasetId?: string(name='DatasetId'),
}

model DatasetUploadFindByDatasetIdResponseBody = {
  content?: [ 
    {
      code?: long(name='Code'),
      datasetId?: long(name='DatasetId'),
      deviceKey?: string(name='DeviceKey'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      message?: string(name='Message'),
      progress?: long(name='Progress'),
      status?: string(name='Status'),
    }
  ](name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: boolean(name='Last'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId', description='Id of the request'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model DatasetUploadFindByDatasetIdResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetUploadFindByDatasetIdResponseBody(name='body'),
}

async function datasetUploadFindByDatasetIdWithOptions(request: DatasetUploadFindByDatasetIdRequest, runtime: Util.RuntimeOptions): DatasetUploadFindByDatasetIdResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetUploadFindByDatasetId',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetUploadFindByDatasetId(request: DatasetUploadFindByDatasetIdRequest): DatasetUploadFindByDatasetIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetUploadFindByDatasetIdWithOptions(request, runtime);
}

model DatasetUploadFindByProjectIdRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  projectId?: long(name='ProjectId'),
  size?: long(name='Size'),
  typeId?: long(name='TypeId'),
}

model DatasetUploadFindByProjectIdResponseBody = {
  datasetUploadInfoResponseList?: [ 
    {
      datasetId?: long(name='DatasetId'),
      datasetOssKey?: string(name='DatasetOssKey'),
      datasetUploadId?: long(name='DatasetUploadId'),
      deviceKey?: string(name='DeviceKey'),
      extInfo?: string(name='ExtInfo'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      progress?: long(name='Progress'),
      status?: string(name='Status'),
    }
  ](name='DatasetUploadInfoResponseList'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model DatasetUploadFindByProjectIdResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetUploadFindByProjectIdResponseBody(name='body'),
}

async function datasetUploadFindByProjectIdWithOptions(request: DatasetUploadFindByProjectIdRequest, runtime: Util.RuntimeOptions): DatasetUploadFindByProjectIdResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.size)) {
    query['Size'] = request.size;
  }
  if (!Util.isUnset(request.typeId)) {
    query['TypeId'] = request.typeId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetUploadFindByProjectId',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetUploadFindByProjectId(request: DatasetUploadFindByProjectIdRequest): DatasetUploadFindByProjectIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetUploadFindByProjectIdWithOptions(request, runtime);
}

model DatasetUploadFindByProjectIdAppRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  projectId?: long(name='ProjectId'),
  typeId?: long(name='TypeId'),
}

model DatasetUploadFindByProjectIdAppResponseBody = {
  code?: string(name='Code'),
  datasetUploadInfoResponseList?: [ 
    {
      datasetId?: long(name='DatasetId'),
      datasetUploadId?: long(name='DatasetUploadId'),
      deviceKey?: string(name='DeviceKey'),
      extInfo?: map[string]any(name='ExtInfo'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      progress?: long(name='Progress'),
      status?: string(name='Status'),
    }
  ](name='DatasetUploadInfoResponseList'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model DatasetUploadFindByProjectIdAppResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DatasetUploadFindByProjectIdAppResponseBody(name='body'),
}

async function datasetUploadFindByProjectIdAppWithOptions(request: DatasetUploadFindByProjectIdAppRequest, runtime: Util.RuntimeOptions): DatasetUploadFindByProjectIdAppResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.typeId)) {
    query['TypeId'] = request.typeId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DatasetUploadFindByProjectIdApp',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function datasetUploadFindByProjectIdApp(request: DatasetUploadFindByProjectIdAppRequest): DatasetUploadFindByProjectIdAppResponse {
  var runtime = new Util.RuntimeOptions{};
  return datasetUploadFindByProjectIdAppWithOptions(request, runtime);
}

model DelBimDrawingRequest {
  id?: long(name='Id', description='归类id'),
  taskId?: string(name='TaskId', description='taskId'),
}

model DelBimDrawingResponseBody = {
  datas?: {
    drawingId?: long(name='DrawingId', description='源图纸id'),
    drawingMode?: string(name='DrawingMode', description='源图纸操作状态'),
    id?: long(name='Id', description='归类id'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DelBimDrawingResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DelBimDrawingResponseBody(name='body'),
}

async function delBimDrawingWithOptions(request: DelBimDrawingRequest, runtime: Util.RuntimeOptions): DelBimDrawingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DelBimDrawing',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function delBimDrawing(request: DelBimDrawingRequest): DelBimDrawingResponse {
  var runtime = new Util.RuntimeOptions{};
  return delBimDrawingWithOptions(request, runtime);
}

model DelBimProjectRequest {
  id?: long(name='Id', description='项目id'),
}

model DelBimProjectResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DelBimProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DelBimProjectResponseBody(name='body'),
}

async function delBimProjectWithOptions(request: DelBimProjectRequest, runtime: Util.RuntimeOptions): DelBimProjectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DelBimProject',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function delBimProject(request: DelBimProjectRequest): DelBimProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return delBimProjectWithOptions(request, runtime);
}

model DeleteMaterialRequest {
  id?: long(name='Id'),
}

model DeleteMaterialResponseBody = {
  data?: map[string]any(name='Data'),
  error?: string(name='Error'),
  msgCode?: string(name='MsgCode'),
  msgInfo?: string(name='MsgInfo'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteMaterialResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteMaterialResponseBody(name='body'),
}

async function deleteMaterialWithOptions(request: DeleteMaterialRequest, runtime: Util.RuntimeOptions): DeleteMaterialResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteMaterial',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteMaterial(request: DeleteMaterialRequest): DeleteMaterialResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteMaterialWithOptions(request, runtime);
}

model DeleteMaterialsRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model DeleteMaterialsResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request'),
}

model DeleteMaterialsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteMaterialsResponseBody(name='body'),
}

async function deleteMaterialsWithOptions(request: DeleteMaterialsRequest, runtime: Util.RuntimeOptions): DeleteMaterialsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteMaterials',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteMaterials(request: DeleteMaterialsRequest): DeleteMaterialsResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteMaterialsWithOptions(request, runtime);
}

model DeleteOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  projectId?: long(name='ProjectId'),
}

model DeleteOneResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model DeleteOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteOneResponseBody(name='body'),
}

async function deleteOneWithOptions(request: DeleteOneRequest, runtime: Util.RuntimeOptions): DeleteOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteOne(request: DeleteOneRequest): DeleteOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteOneWithOptions(request, runtime);
}

model DeleteProjectTransModelRequest {
  taskId?: long(name='TaskId'),
  transModelId?: long(name='TransModelId', description='转换图纸id'),
}

model DeleteProjectTransModelResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteProjectTransModelResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteProjectTransModelResponseBody(name='body'),
}

async function deleteProjectTransModelWithOptions(request: DeleteProjectTransModelRequest, runtime: Util.RuntimeOptions): DeleteProjectTransModelResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.transModelId)) {
    query['TransModelId'] = request.transModelId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteProjectTransModel',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteProjectTransModel(request: DeleteProjectTransModelRequest): DeleteProjectTransModelResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteProjectTransModelWithOptions(request, runtime);
}

model DeleteQRCodeRequest {
  SId?: string(name='SId', description='sId'),
}

model DeleteQRCodeResponseBody = {
  data?: string(name='Data', description='data'),
  error?: string(name='Error', description='error'),
  msgCode?: string(name='MsgCode', description='msgCode'),
  msgInfo?: string(name='MsgInfo', description='msgInfo'),
  requestId?: string(name='RequestId', description='traceId'),
  success?: boolean(name='Success', description='success'),
}

model DeleteQRCodeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteQRCodeResponseBody(name='body'),
}

async function deleteQRCodeWithOptions(request: DeleteQRCodeRequest, runtime: Util.RuntimeOptions): DeleteQRCodeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.SId)) {
    query['SId'] = request.SId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteQRCode',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteQRCode(request: DeleteQRCodeRequest): DeleteQRCodeResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteQRCodeWithOptions(request, runtime);
}

model DisabelUserRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  userId?: long(name='UserId'),
}

model DisabelUserResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: string(name='Success'),
}

model DisabelUserResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DisabelUserResponseBody(name='body'),
}

async function disabelUserWithOptions(request: DisabelUserRequest, runtime: Util.RuntimeOptions): DisabelUserResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.userId)) {
    query['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DisabelUser',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function disabelUser(request: DisabelUserRequest): DisabelUserResponse {
  var runtime = new Util.RuntimeOptions{};
  return disabelUserWithOptions(request, runtime);
}

model FindRegionRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  regionCode?: long(name='RegionCode'),
}

model FindRegionResponseBody = {
  async?: boolean(name='Async'),
  asyncToken?: string(name='AsyncToken'),
  errorCode?: string(name='ErrorCode'),
  errorMsg?: float(name='ErrorMsg'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: {
    regionList?: [  map[string]any ](name='RegionList'),
  }(name='ResultObj'),
  retry?: boolean(name='Retry'),
  success?: boolean(name='Success'),
  traceId?: string(name='TraceId'),
}

model FindRegionResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: FindRegionResponseBody(name='body'),
}

async function findRegionWithOptions(request: FindRegionRequest, runtime: Util.RuntimeOptions): FindRegionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.regionCode)) {
    query['RegionCode'] = request.regionCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'FindRegion',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function findRegion(request: FindRegionRequest): FindRegionResponse {
  var runtime = new Util.RuntimeOptions{};
  return findRegionWithOptions(request, runtime);
}

model FloorPlanRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  body?: string(name='Body'),
  ossKey?: string(name='OssKey'),
}

model FloorPlanResponseBody = {
  code?: long(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model FloorPlanResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: FloorPlanResponseBody(name='body'),
}

async function floorPlanWithOptions(request: FloorPlanRequest, runtime: Util.RuntimeOptions): FloorPlanResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.body)) {
    query['Body'] = request.body;
  }
  if (!Util.isUnset(request.ossKey)) {
    query['OssKey'] = request.ossKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'FloorPlan',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function floorPlan(request: FloorPlanRequest): FloorPlanResponse {
  var runtime = new Util.RuntimeOptions{};
  return floorPlanWithOptions(request, runtime);
}

model GetBimDrawingDetailRequest {
  drawingId?: long(name='DrawingId'),
  taskId?: long(name='TaskId', description='任务id'),
}

model GetBimDrawingDetailResponseBody = {
  datas?: map[string]any(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimDrawingDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimDrawingDetailResponseBody(name='body'),
}

async function getBimDrawingDetailWithOptions(request: GetBimDrawingDetailRequest, runtime: Util.RuntimeOptions): GetBimDrawingDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.drawingId)) {
    query['DrawingId'] = request.drawingId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimDrawingDetail',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimDrawingDetail(request: GetBimDrawingDetailRequest): GetBimDrawingDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimDrawingDetailWithOptions(request, runtime);
}

model GetBimDrawingListRequest {
  taskId?: string(name='TaskId', description='任务id'),
}

model GetBimDrawingListResponseBody = {
  datas?: {
    architecture?: [ 
      {
        fileId?: long(name='FileId'),
        id?: long(name='Id'),
        mode?: string(name='Mode'),
        name?: string(name='Name'),
        status?: string(name='Status'),
        subject?: string(name='Subject'),
        taskId?: long(name='TaskId'),
      }
    ](name='Architecture'),
    structure?: [ 
      {
        fileId?: long(name='FileId'),
        id?: long(name='Id'),
        mode?: string(name='Mode'),
        name?: string(name='Name'),
        status?: string(name='Status'),
        subject?: string(name='Subject'),
        taskId?: long(name='TaskId'),
      }
    ](name='Structure'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimDrawingListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimDrawingListResponseBody(name='body'),
}

async function getBimDrawingListWithOptions(request: GetBimDrawingListRequest, runtime: Util.RuntimeOptions): GetBimDrawingListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimDrawingList',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimDrawingList(request: GetBimDrawingListRequest): GetBimDrawingListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimDrawingListWithOptions(request, runtime);
}

model GetBimDrawingRenderRequest {
  drawingId?: long(name='DrawingId', description='源图纸id'),
  taskId?: long(name='TaskId'),
}

model GetBimDrawingRenderResponseBody = {
  datas?: {
    blocks?: map[string]any(name='Blocks'),
    fontPrefix?: string(name='FontPrefix'),
    geometryPrefix?: string(name='GeometryPrefix'),
    path?: string(name='Path'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimDrawingRenderResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimDrawingRenderResponseBody(name='body'),
}

async function getBimDrawingRenderWithOptions(request: GetBimDrawingRenderRequest, runtime: Util.RuntimeOptions): GetBimDrawingRenderResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.drawingId)) {
    query['DrawingId'] = request.drawingId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimDrawingRender',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimDrawingRender(request: GetBimDrawingRenderRequest): GetBimDrawingRenderResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimDrawingRenderWithOptions(request, runtime);
}

model GetBimDrawingStatusRequest {
  ids?: [ long ](name='Ids', description='原图纸id'),
}

model GetBimDrawingStatusShrinkRequest {
  idsShrink?: string(name='Ids', description='原图纸id'),
}

model GetBimDrawingStatusResponseBody = {
  datas?: [ 
    {
      id?: long(name='Id'),
      mode?: string(name='Mode'),
      status?: string(name='Status'),
    }
  ](name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimDrawingStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimDrawingStatusResponseBody(name='body'),
}

async function getBimDrawingStatusWithOptions(tmpReq: GetBimDrawingStatusRequest, runtime: Util.RuntimeOptions): GetBimDrawingStatusResponse {
  Util.validateModel(tmpReq);
  var request = new GetBimDrawingStatusShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.ids)) {
    request.idsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.ids, 'Ids', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.idsShrink)) {
    query['Ids'] = request.idsShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimDrawingStatus',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimDrawingStatus(request: GetBimDrawingStatusRequest): GetBimDrawingStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimDrawingStatusWithOptions(request, runtime);
}

model GetBimFragmentListRequest {
  drawingId?: long(name='DrawingId'),
  taskId?: long(name='TaskId'),
}

model GetBimFragmentListResponseBody = {
  datas?: [ 
    {
      buildingNo?: string(name='BuildingNo'),
      coordinates?: [[ double ]      ](name='Coordinates'),
      drawingId?: long(name='DrawingId'),
      floorInfo?: [ 
        {
          floorName?: string(name='FloorName'),
          floorNum?: string(name='FloorNum'),
        }
      ](name='FloorInfo'),
      id?: long(name='Id'),
      selectionMode?: string(name='SelectionMode'),
      subType?: string(name='SubType'),
      subject?: string(name='Subject'),
      suffix?: string(name='Suffix'),
      type?: string(name='Type'),
    }
  ](name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimFragmentListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimFragmentListResponseBody(name='body'),
}

async function getBimFragmentListWithOptions(request: GetBimFragmentListRequest, runtime: Util.RuntimeOptions): GetBimFragmentListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.drawingId)) {
    query['DrawingId'] = request.drawingId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimFragmentList',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimFragmentList(request: GetBimFragmentListRequest): GetBimFragmentListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimFragmentListWithOptions(request, runtime);
}

model GetBimGlbModelListRequest {
  taskId?: long(name='TaskId'),
}

model GetBimGlbModelListResponseBody = {
  datas?: {
    bounds?: {
      max?: [ long ](name='Max'),
      min?: [ long ](name='Min'),
    }(name='Bounds'),
    buildings?: [ 
      {
        buildingNo?: string(name='BuildingNo'),
        floors?: [ 
          {
            architecture?: string(name='Architecture'),
            floorNo?: string(name='FloorNo'),
            floorType?: string(name='FloorType'),
            structure?: string(name='Structure'),
          }
        ](name='Floors'),
      }
    ](name='Buildings'),
    name?: string(name='Name'),
    stsToken?: {
      accessKeyId?: string(name='AccessKeyId'),
      accessKeySecret?: string(name='AccessKeySecret'),
      expiration?: long(name='Expiration'),
      ossBucket?: string(name='OssBucket'),
      ossRegion?: string(name='OssRegion'),
      securityToken?: string(name='SecurityToken'),
    }(name='StsToken'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimGlbModelListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimGlbModelListResponseBody(name='body'),
}

async function getBimGlbModelListWithOptions(request: GetBimGlbModelListRequest, runtime: Util.RuntimeOptions): GetBimGlbModelListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimGlbModelList',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimGlbModelList(request: GetBimGlbModelListRequest): GetBimGlbModelListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimGlbModelListWithOptions(request, runtime);
}

model GetBimModelConfigRequest {
  taskId?: long(name='TaskId', description='任务id'),
}

model GetBimModelConfigResponseBody = {
  datas?: {
    beamHeight?: long(name='BeamHeight', description='梁高'),
    beamMode?: long(name='BeamMode', description='梁模式'),
    beamOffset?: long(name='BeamOffset', description='梁偏移'),
    doorHeight?: long(name='DoorHeight', description='门高'),
    doorOffset?: long(name='DoorOffset', description='门偏移'),
    id?: long(name='Id', description='模型规则id'),
    roomMode?: long(name='RoomMode', description='房间模式'),
    slabMode?: long(name='SlabMode', description='板模式'),
    slabThickness?: long(name='SlabThickness', description='板厚度'),
    windowHeight?: long(name='WindowHeight', description='窗高'),
    windowOffset?: long(name='WindowOffset', description='窗偏移量'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimModelConfigResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimModelConfigResponseBody(name='body'),
}

async function getBimModelConfigWithOptions(request: GetBimModelConfigRequest, runtime: Util.RuntimeOptions): GetBimModelConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimModelConfig',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimModelConfig(request: GetBimModelConfigRequest): GetBimModelConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimModelConfigWithOptions(request, runtime);
}

model GetBimOriginModelRequest {
  taskId?: long(name='TaskId'),
}

model GetBimOriginModelResponseBody = {
  datas?: {
    fileId?: long(name='FileId'),
    id?: long(name='Id'),
    modelName?: string(name='ModelName'),
    path?: string(name='Path'),
    taskId?: long(name='TaskId'),
    type?: string(name='Type'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  traceId?: string(name='TraceId'),
}

model GetBimOriginModelResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimOriginModelResponseBody(name='body'),
}

async function getBimOriginModelWithOptions(request: GetBimOriginModelRequest, runtime: Util.RuntimeOptions): GetBimOriginModelResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimOriginModel',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimOriginModel(request: GetBimOriginModelRequest): GetBimOriginModelResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimOriginModelWithOptions(request, runtime);
}

model GetBimProjectDetailRequest {
  taskId?: long(name='TaskId'),
}

model GetBimProjectDetailResponseBody = {
  datas?: {
    component?: [ string ](name='Component', description='模型构件'),
    createTime?: string(name='CreateTime'),
    id?: long(name='Id', description='任务id（项目id）'),
    modelingStatus?: long(name='ModelingStatus'),
    name?: string(name='Name', description='项目名称'),
    phase?: string(name='Phase', description='阶段'),
    remarks?: string(name='Remarks', description='备注'),
    renderable?: long(name='Renderable'),
    status?: string(name='Status'),
    tenantId?: long(name='TenantId', description='租户id'),
    transStatus?: long(name='TransStatus', description='图纸转换状态'),
    type?: string(name='Type', description='类型'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimProjectDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimProjectDetailResponseBody(name='body'),
}

async function getBimProjectDetailWithOptions(request: GetBimProjectDetailRequest, runtime: Util.RuntimeOptions): GetBimProjectDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimProjectDetail',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimProjectDetail(request: GetBimProjectDetailRequest): GetBimProjectDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimProjectDetailWithOptions(request, runtime);
}

model GetBimProjectDrawFilesRequest {
  subject?: string(name='Subject'),
  taskId?: long(name='TaskId'),
}

model GetBimProjectDrawFilesResponseBody = {
  datas?: [ 
    {
      id?: long(name='Id'),
      mode?: string(name='Mode'),
      name?: string(name='Name'),
      status?: string(name='Status'),
      subject?: string(name='Subject'),
      taskId?: long(name='TaskId'),
    }
  ](name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimProjectDrawFilesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimProjectDrawFilesResponseBody(name='body'),
}

async function getBimProjectDrawFilesWithOptions(request: GetBimProjectDrawFilesRequest, runtime: Util.RuntimeOptions): GetBimProjectDrawFilesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.subject)) {
    query['Subject'] = request.subject;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimProjectDrawFiles',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimProjectDrawFiles(request: GetBimProjectDrawFilesRequest): GetBimProjectDrawFilesResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimProjectDrawFilesWithOptions(request, runtime);
}

model GetBimProjectListRequest {
  name?: string(name='Name'),
  pageNum?: long(name='PageNum'),
  pageSize?: long(name='PageSize'),
  phase?: string(name='Phase'),
  status?: string(name='Status'),
  type?: string(name='Type'),
}

model GetBimProjectListResponseBody = {
  datas?: {
    count?: long(name='Count', description='总条数'),
    list?: [ 
      {
        createTime?: string(name='CreateTime', description='创建时间'),
        id?: long(name='Id', description='项目id'),
        modelingStatus?: long(name='ModelingStatus', description='模型构建状态'),
        name?: string(name='Name', description='项目名'),
        phase?: string(name='Phase', description='当前阶段'),
        remarks?: string(name='Remarks', description='备注'),
        renderable?: long(name='Renderable', description='是否可以渲染3d；1是0否'),
        status?: long(name='Status', description='当前项目状态'),
        tenantId?: long(name='TenantId', description='租户id'),
        transStatus?: long(name='TransStatus', description='图纸转换状态'),
        type?: string(name='Type', description='类型'),
        updateTime?: string(name='UpdateTime', description='修改时间'),
      }
    ](name='List', description='返回数据集合'),
    pageNum?: long(name='PageNum', description='当前页'),
    pageSize?: long(name='PageSize', description='每页大小'),
    pages?: long(name='Pages', description='总共多少页'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimProjectListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimProjectListResponseBody(name='body'),
}

async function getBimProjectListWithOptions(request: GetBimProjectListRequest, runtime: Util.RuntimeOptions): GetBimProjectListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.pageNum)) {
    query['PageNum'] = request.pageNum;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.phase)) {
    query['Phase'] = request.phase;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimProjectList',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimProjectList(request: GetBimProjectListRequest): GetBimProjectListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimProjectListWithOptions(request, runtime);
}

model GetBimProjectListStatusRequest {
  ids?: [ long ](name='Ids'),
}

model GetBimProjectListStatusShrinkRequest {
  idsShrink?: string(name='Ids'),
}

model GetBimProjectListStatusResponseBody = {
  datas?: [ 
    {
      id?: long(name='Id'),
      modelingStatus?: long(name='ModelingStatus'),
      phase?: string(name='Phase'),
      status?: string(name='Status'),
      transStatus?: long(name='TransStatus'),
    }
  ](name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimProjectListStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimProjectListStatusResponseBody(name='body'),
}

async function getBimProjectListStatusWithOptions(tmpReq: GetBimProjectListStatusRequest, runtime: Util.RuntimeOptions): GetBimProjectListStatusResponse {
  Util.validateModel(tmpReq);
  var request = new GetBimProjectListStatusShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.ids)) {
    request.idsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.ids, 'Ids', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.idsShrink)) {
    query['Ids'] = request.idsShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimProjectListStatus',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimProjectListStatus(request: GetBimProjectListStatusRequest): GetBimProjectListStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimProjectListStatusWithOptions(request, runtime);
}

model GetBimProjectShareModelListRequest {
  shareId?: string(name='ShareId'),
}

model GetBimProjectShareModelListResponseBody = {
  datas?: {
    bounds?: {
      max?: [ long ](name='Max'),
      min?: [ long ](name='Min'),
    }(name='Bounds'),
    buildings?: [ 
      {
        buildingNo?: string(name='BuildingNo'),
        floors?: [ 
          {
            architecture?: string(name='Architecture'),
            floorNo?: string(name='FloorNo'),
            floorType?: string(name='FloorType'),
            structure?: string(name='Structure'),
          }
        ](name='Floors'),
      }
    ](name='Buildings'),
    name?: string(name='Name'),
    stsToken?: {
      accessKeyId?: string(name='AccessKeyId'),
      accessKeySecret?: string(name='AccessKeySecret'),
      expiration?: long(name='Expiration'),
      ossBucket?: string(name='OssBucket'),
      ossRegion?: string(name='OssRegion'),
      securityToken?: string(name='SecurityToken'),
    }(name='StsToken'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimProjectShareModelListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimProjectShareModelListResponseBody(name='body'),
}

async function getBimProjectShareModelListWithOptions(request: GetBimProjectShareModelListRequest, runtime: Util.RuntimeOptions): GetBimProjectShareModelListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.shareId)) {
    query['ShareId'] = request.shareId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimProjectShareModelList',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'Anonymous',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimProjectShareModelList(request: GetBimProjectShareModelListRequest): GetBimProjectShareModelListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimProjectShareModelListWithOptions(request, runtime);
}

model GetBimStandardAutoMarkRequest {
  standardId?: long(name='StandardId', description='标准图纸id'),
  taskId?: long(name='TaskId', description='任务id'),
}

model GetBimStandardAutoMarkResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimStandardAutoMarkResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimStandardAutoMarkResponseBody(name='body'),
}

async function getBimStandardAutoMarkWithOptions(request: GetBimStandardAutoMarkRequest, runtime: Util.RuntimeOptions): GetBimStandardAutoMarkResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.standardId)) {
    query['StandardId'] = request.standardId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimStandardAutoMark',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimStandardAutoMark(request: GetBimStandardAutoMarkRequest): GetBimStandardAutoMarkResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimStandardAutoMarkWithOptions(request, runtime);
}

model GetBimStandardListRequest {
  taskId?: long(name='TaskId', description='任务id'),
}

model GetBimStandardListResponseBody = {
  datas?: [ 
    {
      architecture?: {
        detail?: [  map[string]any ](name='Detail'),
        elevation?: [  map[string]any ](name='Elevation'),
        plan?: [  map[string]any ](name='Plan'),
      }(name='Architecture'),
      buildingNo?: string(name='BuildingNo'),
      structure?: {
        detail?: [  map[string]any ](name='Detail'),
        elevation?: [  map[string]any ](name='Elevation'),
        plan?: [  map[string]any ](name='Plan'),
        sample?: [  map[string]any ](name='Sample'),
      }(name='Structure'),
    }
  ](name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimStandardListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimStandardListResponseBody(name='body'),
}

async function getBimStandardListWithOptions(request: GetBimStandardListRequest, runtime: Util.RuntimeOptions): GetBimStandardListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimStandardList',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimStandardList(request: GetBimStandardListRequest): GetBimStandardListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimStandardListWithOptions(request, runtime);
}

model GetBimStandardPlanRequest {
  standard?: long(name='Standard', description='标准图纸id'),
  taskId?: long(name='TaskId'),
}

model GetBimStandardPlanResponseBody = {
  datas?: {
    config?: {
      id?: long(name='Id', description='标注信息id'),
      mapInfo?: [ 
        {
          layer?: string(name='Layer', description='图层归类名'),
          list?: [ 
            {
              id?: long(name='Id', description='图层id'),
              name?: string(name='Name', description='图层名'),
            }
          ](name='List', description='图层信息'),
        }
      ](name='MapInfo', description='图层归类信息'),
    }(name='Config', description='标注配置信息'),
    id?: long(name='Id', description='标准图纸id'),
    status?: long(name='Status', description='标准图纸状态'),
    templateConfig?: {
      id?: long(name='Id', description='最近一次标注配置id'),
      mapInfo?: [ 
        {
          layer?: string(name='Layer', description='最近一次图层名'),
          list?: [ 
            {
              id?: long(name='Id'),
              name?: string(name='Name'),
            }
          ](name='List', description='最近一次图层id'),
        }
      ](name='MapInfo', description='最近一次图层信息'),
    }(name='TemplateConfig', description='最近一次标注配置'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimStandardPlanResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimStandardPlanResponseBody(name='body'),
}

async function getBimStandardPlanWithOptions(request: GetBimStandardPlanRequest, runtime: Util.RuntimeOptions): GetBimStandardPlanResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.standard)) {
    query['Standard'] = request.standard;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimStandardPlan',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimStandardPlan(request: GetBimStandardPlanRequest): GetBimStandardPlanResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimStandardPlanWithOptions(request, runtime);
}

model GetBimStandardRenderRequest {
  standardId?: long(name='StandardId', description='标准图纸id'),
  taskId?: long(name='TaskId'),
}

model GetBimStandardRenderResponseBody = {
  datas?: {
    blocks?: map[string]any(name='Blocks'),
    fontPrefix?: string(name='FontPrefix'),
    geometryPrefix?: string(name='GeometryPrefix'),
    path?: string(name='Path'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimStandardRenderResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimStandardRenderResponseBody(name='body'),
}

async function getBimStandardRenderWithOptions(request: GetBimStandardRenderRequest, runtime: Util.RuntimeOptions): GetBimStandardRenderResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.standardId)) {
    query['StandardId'] = request.standardId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimStandardRender',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimStandardRender(request: GetBimStandardRenderRequest): GetBimStandardRenderResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimStandardRenderWithOptions(request, runtime);
}

model GetBimStandardSampleRequest {
  standardId?: long(name='StandardId', description='标准图纸id'),
  taskId?: long(name='TaskId', description='任务id'),
}

model GetBimStandardSampleResponseBody = {
  datas?: {
    data?: {
      legends?: [ 
        {
          elevationHeight?: map[string]any(name='ElevationHeight', description='底标高'),
          elevationMode?: string(name='ElevationMode', description='标高模式'),
          elevationOperator?: string(name='ElevationOperator', description='标高运算'),
          patternName?: string(name='PatternName', description='板名'),
          picture?: string(name='Picture', description='板图片'),
          thickness?: long(name='Thickness', description='板厚度'),
        }
      ](name='Legends'),
      rootDir?: string(name='RootDir', description='根文件夹'),
      thickness?: long(name='Thickness', description='默认厚度'),
    }(name='Data', description='大样结构板数据'),
    id?: long(name='Id', description='标准图纸id'),
    status?: long(name='Status', description='图纸状态'),
  }(name='Datas', description='接口返回数据'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimStandardSampleResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimStandardSampleResponseBody(name='body'),
}

async function getBimStandardSampleWithOptions(request: GetBimStandardSampleRequest, runtime: Util.RuntimeOptions): GetBimStandardSampleResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.standardId)) {
    query['StandardId'] = request.standardId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimStandardSample',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimStandardSample(request: GetBimStandardSampleRequest): GetBimStandardSampleResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimStandardSampleWithOptions(request, runtime);
}

model GetBimStandardStatusByIdsRequest {
  ids?: [ long ](name='Ids'),
  taskId?: long(name='TaskId'),
}

model GetBimStandardStatusByIdsShrinkRequest {
  idsShrink?: string(name='Ids'),
  taskId?: long(name='TaskId'),
}

model GetBimStandardStatusByIdsResponseBody = {
  datas?: [ 
    {
      id?: long(name='Id', description='标准图纸id'),
      status?: long(name='Status', description='标准图纸状态'),
    }
  ](name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimStandardStatusByIdsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimStandardStatusByIdsResponseBody(name='body'),
}

async function getBimStandardStatusByIdsWithOptions(tmpReq: GetBimStandardStatusByIdsRequest, runtime: Util.RuntimeOptions): GetBimStandardStatusByIdsResponse {
  Util.validateModel(tmpReq);
  var request = new GetBimStandardStatusByIdsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.ids)) {
    request.idsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.ids, 'Ids', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.idsShrink)) {
    query['Ids'] = request.idsShrink;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimStandardStatusByIds',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimStandardStatusByIds(request: GetBimStandardStatusByIdsRequest): GetBimStandardStatusByIdsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimStandardStatusByIdsWithOptions(request, runtime);
}

model GetBimTaskDetailRequest {
  taskId?: long(name='TaskId'),
}

model GetBimTaskDetailResponseBody = {
  datas?: {
    id?: long(name='Id', description='任务id'),
    modelingStatus?: long(name='ModelingStatus', description='模型状态'),
    phase?: string(name='Phase', description='阶段'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimTaskDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimTaskDetailResponseBody(name='body'),
}

async function getBimTaskDetailWithOptions(request: GetBimTaskDetailRequest, runtime: Util.RuntimeOptions): GetBimTaskDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimTaskDetail',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimTaskDetail(request: GetBimTaskDetailRequest): GetBimTaskDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimTaskDetailWithOptions(request, runtime);
}

model GetBimTenantFlowRequest {
  regionId?: string(name='RegionId'),
}

model GetBimTenantFlowResponseBody = {
  datas?: {
    company?: string(name='Company', description='单位（B,KB,M）'),
    flow?: long(name='Flow', description='总流量'),
    usedFlow?: long(name='UsedFlow', description='已用流量'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimTenantFlowResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimTenantFlowResponseBody(name='body'),
}

async function getBimTenantFlowWithOptions(request: GetBimTenantFlowRequest, runtime: Util.RuntimeOptions): GetBimTenantFlowResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimTenantFlow',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimTenantFlow(request: GetBimTenantFlowRequest): GetBimTenantFlowResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimTenantFlowWithOptions(request, runtime);
}

model GetBimTransModelListRequest {
  taskId?: long(name='TaskId'),
}

model GetBimTransModelListResponseBody = {
  datas?: [ 
    {
      commpany?: string(name='Commpany', description='单位（B,MB）'),
      endTime?: string(name='EndTime'),
      fileId?: long(name='FileId'),
      id?: long(name='Id', description='转换模型id'),
      modelName?: string(name='ModelName', description='模型名称'),
      path?: string(name='Path'),
      size?: long(name='Size', description='大小'),
      status?: long(name='Status'),
      taskId?: long(name='TaskId'),
      type?: string(name='Type'),
    }
  ](name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimTransModelListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimTransModelListResponseBody(name='body'),
}

async function getBimTransModelListWithOptions(request: GetBimTransModelListRequest, runtime: Util.RuntimeOptions): GetBimTransModelListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimTransModelList',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimTransModelList(request: GetBimTransModelListRequest): GetBimTransModelListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimTransModelListWithOptions(request, runtime);
}

model GetBimUploadStsTokenRequest {
  taskId?: long(name='TaskId'),
}

model GetBimUploadStsTokenResponseBody = {
  datas?: {
    accessKeyId?: string(name='AccessKeyId'),
    accessKeySecret?: string(name='AccessKeySecret'),
    expiration?: long(name='Expiration'),
    ossBucket?: string(name='OssBucket'),
    ossRegion?: string(name='OssRegion'),
    path?: string(name='Path', description='路径'),
    securityToken?: string(name='SecurityToken'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetBimUploadStsTokenResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetBimUploadStsTokenResponseBody(name='body'),
}

async function getBimUploadStsTokenWithOptions(request: GetBimUploadStsTokenRequest, runtime: Util.RuntimeOptions): GetBimUploadStsTokenResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBimUploadStsToken',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBimUploadStsToken(request: GetBimUploadStsTokenRequest): GetBimUploadStsTokenResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBimUploadStsTokenWithOptions(request, runtime);
}

model GetCurrentUserRequest {
  aliyunJwt?: string(name='AliyunJwt'),
}

model GetCurrentUserResponseBody = {
  code?: string(name='Code'),
  companyId?: long(name='CompanyId'),
  companyName?: string(name='CompanyName'),
  email?: string(name='Email'),
  ext1?: string(name='Ext1'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  menus?: [ 
    {
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      status?: string(name='Status'),
      url?: string(name='Url'),
    }
  ](name='Menus'),
  message?: string(name='Message'),
  name?: string(name='Name'),
  phone?: string(name='Phone'),
  requestId?: string(name='RequestId', description='Id of the request'),
  roles?: [ 
    {
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      parentId?: long(name='ParentId'),
      status?: string(name='Status'),
      type?: string(name='Type'),
    }
  ](name='Roles'),
  status?: string(name='Status'),
}

model GetCurrentUserResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetCurrentUserResponseBody(name='body'),
}

async function getCurrentUserWithOptions(request: GetCurrentUserRequest, runtime: Util.RuntimeOptions): GetCurrentUserResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCurrentUser',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCurrentUser(request: GetCurrentUserRequest): GetCurrentUserResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCurrentUserWithOptions(request, runtime);
}

model GetFormatFilePathRequest {
  format?: string(name='Format'),
  jwt?: string(name='Jwt'),
  orderId?: long(name='OrderId'),
}

model GetFormatFilePathResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  result?: {
    path?: string(name='Path'),
  }(name='Result'),
}

model GetFormatFilePathResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetFormatFilePathResponseBody(name='body'),
}

async function getFormatFilePathWithOptions(request: GetFormatFilePathRequest, runtime: Util.RuntimeOptions): GetFormatFilePathResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.jwt)) {
    query['Jwt'] = request.jwt;
  }
  var body : map[string]any= {};
  if (!Util.isUnset(request.format)) {
    body['Format'] = request.format;
  }
  if (!Util.isUnset(request.orderId)) {
    body['OrderId'] = request.orderId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetFormatFilePath',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getFormatFilePath(request: GetFormatFilePathRequest): GetFormatFilePathResponse {
  var runtime = new Util.RuntimeOptions{};
  return getFormatFilePathWithOptions(request, runtime);
}

model GetInstancesRequest {
  pipelineNodeId?: string(name='PipelineNodeId'),
}

model GetInstancesResponseBody = {
  content?: string(name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: boolean(name='Last'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId', description='Id of the request'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model GetInstancesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetInstancesResponseBody(name='body'),
}

async function getInstancesWithOptions(request: GetInstancesRequest, runtime: Util.RuntimeOptions): GetInstancesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.pipelineNodeId)) {
    query['PipelineNodeId'] = request.pipelineNodeId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetInstances',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getInstances(request: GetInstancesRequest): GetInstancesResponse {
  var runtime = new Util.RuntimeOptions{};
  return getInstancesWithOptions(request, runtime);
}

model GetJwtCommonRequest {
  loginType?: string(name='LoginType'),
  tenantCode?: string(name='TenantCode'),
  tenantUid?: string(name='TenantUid'),
}

model GetJwtCommonResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  result?: map[string]any(name='Result', description='对象实例。'),
}

model GetJwtCommonResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetJwtCommonResponseBody(name='body'),
}

async function getJwtCommonWithOptions(request: GetJwtCommonRequest, runtime: Util.RuntimeOptions): GetJwtCommonResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.loginType)) {
    body['LoginType'] = request.loginType;
  }
  if (!Util.isUnset(request.tenantCode)) {
    body['TenantCode'] = request.tenantCode;
  }
  if (!Util.isUnset(request.tenantUid)) {
    body['TenantUid'] = request.tenantUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetJwtCommon',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getJwtCommon(request: GetJwtCommonRequest): GetJwtCommonResponse {
  var runtime = new Util.RuntimeOptions{};
  return getJwtCommonWithOptions(request, runtime);
}

model GetLatestNodeByTypeRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  pipelineNodeType?: string(name='PipelineNodeType'),
}

model GetLatestNodeByTypeResponseBody = {
  enabled?: string(name='Enabled'),
  exposed?: string(name='Exposed'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: string(name='Id'),
  order?: string(name='Order'),
  parentId?: string(name='ParentId'),
  requestId?: string(name='RequestId', description='Id of the request'),
  usage?: string(name='Usage'),
}

model GetLatestNodeByTypeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetLatestNodeByTypeResponseBody(name='body'),
}

async function getLatestNodeByTypeWithOptions(request: GetLatestNodeByTypeRequest, runtime: Util.RuntimeOptions): GetLatestNodeByTypeResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetLatestNodeByType',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getLatestNodeByType(request: GetLatestNodeByTypeRequest): GetLatestNodeByTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getLatestNodeByTypeWithOptions(request, runtime);
}

model GetMaterialListRequest {
  current?: int32(name='Current'),
  name?: string(name='Name'),
  size?: int32(name='Size'),
  type?: string(name='Type'),
}

model GetMaterialListResponseBody = {
  data?: map[string]any(name='Data'),
  error?: string(name='Error'),
  msgCode?: string(name='MsgCode'),
  msgInfo?: string(name='MsgInfo'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetMaterialListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetMaterialListResponseBody(name='body'),
}

async function getMaterialListWithOptions(request: GetMaterialListRequest, runtime: Util.RuntimeOptions): GetMaterialListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.current)) {
    query['Current'] = request.current;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.size)) {
    query['Size'] = request.size;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetMaterialList',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getMaterialList(request: GetMaterialListRequest): GetMaterialListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getMaterialListWithOptions(request, runtime);
}

model GetOssCredentialRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  datasetId?: long(name='DatasetId'),
  isCdn?: boolean(name='IsCdn'),
  type?: string(name='Type'),
}

model GetOssCredentialResponseBody = {
  accessKeyId?: string(name='AccessKeyId'),
  accessKeySecret?: string(name='AccessKeySecret'),
  code?: string(name='Code'),
  endpoint?: string(name='Endpoint'),
  expiration?: string(name='Expiration'),
  message?: string(name='Message'),
  ossPath?: string(name='OssPath'),
  requestId?: BaseRequest(name='RequestId'),
  securityToken?: string(name='SecurityToken'),
}

model GetOssCredentialResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOssCredentialResponseBody(name='body'),
}

async function getOssCredentialWithOptions(request: GetOssCredentialRequest, runtime: Util.RuntimeOptions): GetOssCredentialResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.isCdn)) {
    query['IsCdn'] = request.isCdn;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetOssCredential',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOssCredential(request: GetOssCredentialRequest): GetOssCredentialResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOssCredentialWithOptions(request, runtime);
}

model GetOssCredentialsRequest {
  jwt?: string(name='Jwt'),
  orderId?: long(name='OrderId'),
  type?: string(name='Type', description='R: Read only, RW: Read write'),
}

model GetOssCredentialsResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  result?: {
    accessKeyId?: string(name='AccessKeyId'),
    accessKeySecret?: string(name='AccessKeySecret'),
    endpoint?: string(name='Endpoint'),
    expiration?: string(name='Expiration'),
    ossPath?: string(name='OssPath'),
    securityToken?: string(name='SecurityToken'),
  }(name='Result', description='对象实例。'),
}

model GetOssCredentialsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOssCredentialsResponseBody(name='body'),
}

async function getOssCredentialsWithOptions(request: GetOssCredentialsRequest, runtime: Util.RuntimeOptions): GetOssCredentialsResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.jwt)) {
    body['Jwt'] = request.jwt;
  }
  if (!Util.isUnset(request.orderId)) {
    body['OrderId'] = request.orderId;
  }
  if (!Util.isUnset(request.type)) {
    body['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOssCredentials',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOssCredentials(request: GetOssCredentialsRequest): GetOssCredentialsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOssCredentialsWithOptions(request, runtime);
}

model GetProjectPhaseDetailRequest {
  taskId?: long(name='TaskId'),
}

model GetProjectPhaseDetailResponseBody = {
  datas?: {
    currentPhase?: long(name='CurrentPhase', description='当前阶段返回时list下标'),
    list?: [ 
      {
        endTime?: string(name='EndTime'),
        phase?: string(name='Phase'),
        status?: long(name='Status'),
      }
    ](name='List'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetProjectPhaseDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetProjectPhaseDetailResponseBody(name='body'),
}

async function getProjectPhaseDetailWithOptions(request: GetProjectPhaseDetailRequest, runtime: Util.RuntimeOptions): GetProjectPhaseDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetProjectPhaseDetail',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getProjectPhaseDetail(request: GetProjectPhaseDetailRequest): GetProjectPhaseDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getProjectPhaseDetailWithOptions(request, runtime);
}

model GetStatusAndOssRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  body?: string(name='body'),
}

model GetStatusAndOssResponseBody = {
  datasetPublishStatus?: string(name='DatasetPublishStatus'),
  fullName?: string(name='FullName'),
  gmtPublished?: string(name='GmtPublished'),
  icon?: string(name='Icon'),
  nickName?: string(name='NickName'),
  pipelineStatus?: string(name='PipelineStatus'),
  projectId?: long(name='ProjectId'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model GetStatusAndOssResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetStatusAndOssResponseBody(name='body'),
}

async function getStatusAndOssWithOptions(request: GetStatusAndOssRequest, runtime: Util.RuntimeOptions): GetStatusAndOssResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.body)) {
    query['body'] = request.body;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetStatusAndOss',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getStatusAndOss(request: GetStatusAndOssRequest): GetStatusAndOssResponse {
  var runtime = new Util.RuntimeOptions{};
  return getStatusAndOssWithOptions(request, runtime);
}

model GetTemplateListRequest {
  current?: int32(name='Current'),
  id?: long(name='Id'),
  name?: string(name='Name'),
  size?: int32(name='Size'),
  spec?: string(name='Spec'),
  style?: string(name='Style'),
  type?: string(name='Type'),
}

model GetTemplateListResponseBody = {
  data?: map[string]any(name='Data'),
  error?: string(name='Error'),
  msgCode?: string(name='MsgCode'),
  msgInfo?: string(name='MsgInfo'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetTemplateListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetTemplateListResponseBody(name='body'),
}

async function getTemplateListWithOptions(request: GetTemplateListRequest, runtime: Util.RuntimeOptions): GetTemplateListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.current)) {
    query['Current'] = request.current;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.size)) {
    query['Size'] = request.size;
  }
  if (!Util.isUnset(request.spec)) {
    query['Spec'] = request.spec;
  }
  if (!Util.isUnset(request.style)) {
    query['Style'] = request.style;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetTemplateList',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTemplateList(request: GetTemplateListRequest): GetTemplateListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTemplateListWithOptions(request, runtime);
}

model GetTokenRequest {
  pathType?: string(name='PathType'),
}

model GetTokenResponseBody = {
  data?: map[string]any(name='Data'),
  error?: string(name='Error'),
  msgCode?: string(name='MsgCode'),
  msgInfo?: string(name='MsgInfo'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetTokenResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetTokenResponseBody(name='body'),
}

async function getTokenWithOptions(request: GetTokenRequest, runtime: Util.RuntimeOptions): GetTokenResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.pathType)) {
    query['PathType'] = request.pathType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetToken',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getToken(request: GetTokenRequest): GetTokenResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTokenWithOptions(request, runtime);
}

model LogOperationRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model LogOperationResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: boolean(name='ResultObj'),
  success?: string(name='Success'),
}

model LogOperationResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: LogOperationResponseBody(name='body'),
}

async function logOperationWithOptions(request: LogOperationRequest, runtime: Util.RuntimeOptions): LogOperationResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'LogOperation',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function logOperation(request: LogOperationRequest): LogOperationResponse {
  var runtime = new Util.RuntimeOptions{};
  return logOperationWithOptions(request, runtime);
}

model MaterialCreateOnePictureRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model MaterialCreateOnePictureResponseBody = {
  auditStatus?: string(name='AuditStatus'),
  endTime?: long(name='EndTime'),
  fileName?: string(name='FileName'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  ossKey?: string(name='OssKey'),
  remarks?: string(name='Remarks'),
  requestId?: string(name='RequestId', description='Id of the request'),
  source?: string(name='Source'),
  startTime?: long(name='StartTime'),
  thumbnail?: string(name='Thumbnail'),
  uploadStatus?: string(name='UploadStatus'),
  uploader?: string(name='Uploader'),
}

model MaterialCreateOnePictureResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: MaterialCreateOnePictureResponseBody(name='body'),
}

async function materialCreateOnePictureWithOptions(request: MaterialCreateOnePictureRequest, runtime: Util.RuntimeOptions): MaterialCreateOnePictureResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MaterialCreateOnePicture',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function materialCreateOnePicture(request: MaterialCreateOnePictureRequest): MaterialCreateOnePictureResponse {
  var runtime = new Util.RuntimeOptions{};
  return materialCreateOnePictureWithOptions(request, runtime);
}

model MaterialCreateOneVideoRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model MaterialCreateOneVideoResponseBody = {
  auditStatus?: string(name='AuditStatus'),
  endTime?: long(name='EndTime'),
  fileName?: string(name='FileName'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  ossKey?: string(name='OssKey'),
  remarks?: string(name='Remarks'),
  requestId?: string(name='RequestId', description='Id of the request'),
  source?: string(name='Source'),
  startTime?: long(name='StartTime'),
  thumbnail?: string(name='Thumbnail'),
  uploadStatus?: string(name='UploadStatus'),
  uploader?: string(name='Uploader'),
}

model MaterialCreateOneVideoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: MaterialCreateOneVideoResponseBody(name='body'),
}

async function materialCreateOneVideoWithOptions(request: MaterialCreateOneVideoRequest, runtime: Util.RuntimeOptions): MaterialCreateOneVideoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MaterialCreateOneVideo',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function materialCreateOneVideo(request: MaterialCreateOneVideoRequest): MaterialCreateOneVideoResponse {
  var runtime = new Util.RuntimeOptions{};
  return materialCreateOneVideoWithOptions(request, runtime);
}

model MaterialDeleteOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  id?: string(name='Id'),
}

model MaterialDeleteOneResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request'),
}

model MaterialDeleteOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: MaterialDeleteOneResponseBody(name='body'),
}

async function materialDeleteOneWithOptions(request: MaterialDeleteOneRequest, runtime: Util.RuntimeOptions): MaterialDeleteOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MaterialDeleteOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function materialDeleteOne(request: MaterialDeleteOneRequest): MaterialDeleteOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return materialDeleteOneWithOptions(request, runtime);
}

model MaterialFindAllRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  auditStatus?: string(name='AuditStatus'),
  direction?: string(name='Direction'),
  fileName?: string(name='FileName'),
  materialType?: string(name='MaterialType'),
  page?: long(name='Page'),
  size?: long(name='Size'),
  sort?: string(name='Sort'),
  source?: string(name='Source'),
}

model MaterialFindAllResponseBody = {
  content?: [ 
    {
      auditStatus?: string(name='AuditStatus'),
      endTime?: long(name='EndTime'),
      fileName?: string(name='FileName'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      ossKey?: string(name='OssKey'),
      remarks?: string(name='Remarks'),
      source?: string(name='Source'),
      startTime?: long(name='StartTime'),
      thumbnail?: string(name='Thumbnail'),
      uploadStatus?: string(name='UploadStatus'),
      uploader?: string(name='Uploader'),
      url?: string(name='Url'),
    }
  ](name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: boolean(name='Last'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId', description='Id of the request'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model MaterialFindAllResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: MaterialFindAllResponseBody(name='body'),
}

async function materialFindAllWithOptions(request: MaterialFindAllRequest, runtime: Util.RuntimeOptions): MaterialFindAllResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.auditStatus)) {
    query['AuditStatus'] = request.auditStatus;
  }
  if (!Util.isUnset(request.direction)) {
    query['Direction'] = request.direction;
  }
  if (!Util.isUnset(request.fileName)) {
    query['FileName'] = request.fileName;
  }
  if (!Util.isUnset(request.materialType)) {
    query['MaterialType'] = request.materialType;
  }
  if (!Util.isUnset(request.page)) {
    query['Page'] = request.page;
  }
  if (!Util.isUnset(request.size)) {
    query['Size'] = request.size;
  }
  if (!Util.isUnset(request.sort)) {
    query['Sort'] = request.sort;
  }
  if (!Util.isUnset(request.source)) {
    query['Source'] = request.source;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MaterialFindAll',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function materialFindAll(request: MaterialFindAllRequest): MaterialFindAllResponse {
  var runtime = new Util.RuntimeOptions{};
  return materialFindAllWithOptions(request, runtime);
}

model MaterialFindAllPictureRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model MaterialFindAllPictureResponseBody = {
  content?: [ 
    {
      auditStatus?: string(name='AuditStatus'),
      endTime?: long(name='EndTime'),
      fileName?: string(name='FileName'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      ossKey?: string(name='OssKey'),
      realFileName?: string(name='RealFileName'),
      remarks?: string(name='Remarks'),
      source?: string(name='Source'),
      startTime?: long(name='StartTime'),
      thumbnail?: string(name='Thumbnail'),
      uploadStatus?: string(name='UploadStatus'),
      uploader?: string(name='Uploader'),
      url?: string(name='Url'),
    }
  ](name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: boolean(name='Last'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId', description='Id of the request'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model MaterialFindAllPictureResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: MaterialFindAllPictureResponseBody(name='body'),
}

async function materialFindAllPictureWithOptions(request: MaterialFindAllPictureRequest, runtime: Util.RuntimeOptions): MaterialFindAllPictureResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MaterialFindAllPicture',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function materialFindAllPicture(request: MaterialFindAllPictureRequest): MaterialFindAllPictureResponse {
  var runtime = new Util.RuntimeOptions{};
  return materialFindAllPictureWithOptions(request, runtime);
}

model MaterialFindAllVideoRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model MaterialFindAllVideoResponseBody = {
  content?: [ 
    {
      auditStatus?: string(name='AuditStatus'),
      endTime?: long(name='EndTime'),
      fileName?: string(name='FileName'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      ossKey?: string(name='OssKey'),
      realFileName?: string(name='RealFileName'),
      remarks?: string(name='Remarks'),
      source?: string(name='Source'),
      startTime?: long(name='StartTime'),
      thumbnail?: string(name='Thumbnail'),
      uploadStatus?: string(name='UploadStatus'),
      uploader?: string(name='Uploader'),
      url?: string(name='Url'),
    }
  ](name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: boolean(name='Last'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId', description='Id of the request'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model MaterialFindAllVideoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: MaterialFindAllVideoResponseBody(name='body'),
}

async function materialFindAllVideoWithOptions(request: MaterialFindAllVideoRequest, runtime: Util.RuntimeOptions): MaterialFindAllVideoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MaterialFindAllVideo',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function materialFindAllVideo(request: MaterialFindAllVideoRequest): MaterialFindAllVideoResponse {
  var runtime = new Util.RuntimeOptions{};
  return materialFindAllVideoWithOptions(request, runtime);
}

model MaterialFindOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  materialId?: long(name='MaterialId'),
}

model MaterialFindOneResponseBody = {
  auditStatus?: string(name='AuditStatus'),
  endTime?: long(name='EndTime'),
  fileName?: string(name='FileName'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  ossKey?: string(name='OssKey'),
  realFileName?: string(name='RealFileName'),
  remarks?: string(name='Remarks'),
  requestId?: string(name='RequestId', description='Id of the request'),
  source?: string(name='Source'),
  startTime?: long(name='StartTime'),
  thumbnail?: string(name='Thumbnail'),
  uploadStatus?: string(name='UploadStatus'),
  uploader?: string(name='Uploader'),
  url?: string(name='Url'),
}

model MaterialFindOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: MaterialFindOneResponseBody(name='body'),
}

async function materialFindOneWithOptions(request: MaterialFindOneRequest, runtime: Util.RuntimeOptions): MaterialFindOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.materialId)) {
    query['MaterialId'] = request.materialId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MaterialFindOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function materialFindOne(request: MaterialFindOneRequest): MaterialFindOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return materialFindOneWithOptions(request, runtime);
}

model MaterialFlushUploadRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  materialId?: long(name='MaterialId'),
  value?: long(name='Value'),
}

model MaterialFlushUploadResponseBody = {
  auditStatus?: string(name='AuditStatus'),
  endTime?: long(name='EndTime'),
  fileName?: string(name='FileName'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  ossKey?: string(name='OssKey'),
  remarks?: string(name='Remarks'),
  requestId?: string(name='RequestId', description='Id of the request'),
  source?: string(name='Source'),
  startTime?: long(name='StartTime'),
  thumbnail?: string(name='Thumbnail'),
  uploadStatus?: string(name='UploadStatus'),
  uploadValue?: string(name='UploadValue'),
  uploader?: string(name='Uploader'),
  url?: string(name='Url'),
}

model MaterialFlushUploadResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: MaterialFlushUploadResponseBody(name='body'),
}

async function materialFlushUploadWithOptions(request: MaterialFlushUploadRequest, runtime: Util.RuntimeOptions): MaterialFlushUploadResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.materialId)) {
    query['MaterialId'] = request.materialId;
  }
  if (!Util.isUnset(request.value)) {
    query['Value'] = request.value;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MaterialFlushUpload',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function materialFlushUpload(request: MaterialFlushUploadRequest): MaterialFlushUploadResponse {
  var runtime = new Util.RuntimeOptions{};
  return materialFlushUploadWithOptions(request, runtime);
}

model MaterialGetOssCreadentialsRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  type?: string(name='Type'),
}

model MaterialGetOssCreadentialsResponseBody = {
  accessKeyId?: string(name='AccessKeyId'),
  accessKeySecret?: string(name='AccessKeySecret'),
  endpoint?: string(name='Endpoint'),
  expiration?: string(name='Expiration'),
  ossPath?: string(name='OssPath'),
  requestId?: string(name='RequestId', description='Id of the request'),
  securityToken?: string(name='SecurityToken'),
}

model MaterialGetOssCreadentialsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: MaterialGetOssCreadentialsResponseBody(name='body'),
}

async function materialGetOssCreadentialsWithOptions(request: MaterialGetOssCreadentialsRequest, runtime: Util.RuntimeOptions): MaterialGetOssCreadentialsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MaterialGetOssCreadentials',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function materialGetOssCreadentials(request: MaterialGetOssCreadentialsRequest): MaterialGetOssCreadentialsResponse {
  var runtime = new Util.RuntimeOptions{};
  return materialGetOssCreadentialsWithOptions(request, runtime);
}

model MaterialUpdateOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model MaterialUpdateOneResponseBody = {
  auditStatus?: string(name='AuditStatus'),
  endTime?: long(name='EndTime'),
  fileName?: string(name='FileName'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  ossKey?: string(name='OssKey'),
  remarks?: string(name='Remarks'),
  requestId?: string(name='RequestId', description='Id of the request'),
  source?: string(name='Source'),
  startTime?: long(name='StartTime'),
  thumbnail?: string(name='Thumbnail'),
  uploadStatus?: string(name='UploadStatus'),
  uploader?: string(name='Uploader'),
}

model MaterialUpdateOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: MaterialUpdateOneResponseBody(name='body'),
}

async function materialUpdateOneWithOptions(request: MaterialUpdateOneRequest, runtime: Util.RuntimeOptions): MaterialUpdateOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MaterialUpdateOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function materialUpdateOne(request: MaterialUpdateOneRequest): MaterialUpdateOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return materialUpdateOneWithOptions(request, runtime);
}

model OrderAssignedScanISVRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model OrderAssignedScanISVResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: map[string]any(name='ResultObj'),
  success?: boolean(name='Success'),
}

model OrderAssignedScanISVResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderAssignedScanISVResponseBody(name='body'),
}

async function orderAssignedScanISVWithOptions(request: OrderAssignedScanISVRequest, runtime: Util.RuntimeOptions): OrderAssignedScanISVResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OrderAssignedScanISV',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderAssignedScanISV(request: OrderAssignedScanISVRequest): OrderAssignedScanISVResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderAssignedScanISVWithOptions(request, runtime);
}

model OrderBatchCreateRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model OrderBatchCreateResponseBody = {
  errorCode?: string(name='ErrorCode', description='errorCode'),
  errorMsg?: string(name='ErrorMsg', description='errorMsg'),
  requestId?: string(name='RequestId', description='traceId'),
  resultObj?: map[string]any(name='ResultObj', description='resultObj'),
  success?: boolean(name='Success', description='success'),
}

model OrderBatchCreateResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderBatchCreateResponseBody(name='body'),
}

async function orderBatchCreateWithOptions(request: OrderBatchCreateRequest, runtime: Util.RuntimeOptions): OrderBatchCreateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OrderBatchCreate',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderBatchCreate(request: OrderBatchCreateRequest): OrderBatchCreateResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderBatchCreateWithOptions(request, runtime);
}

model OrderBatchDeleteRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model OrderBatchDeleteResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: map[string]any(name='ResultObj'),
  success?: boolean(name='Success'),
}

model OrderBatchDeleteResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderBatchDeleteResponseBody(name='body'),
}

async function orderBatchDeleteWithOptions(request: OrderBatchDeleteRequest, runtime: Util.RuntimeOptions): OrderBatchDeleteResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OrderBatchDelete',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderBatchDelete(request: OrderBatchDeleteRequest): OrderBatchDeleteResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderBatchDeleteWithOptions(request, runtime);
}

model OrderBatchUpdateOrderStateRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model OrderBatchUpdateOrderStateResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: map[string]any(name='ResultObj'),
  success?: boolean(name='Success'),
}

model OrderBatchUpdateOrderStateResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderBatchUpdateOrderStateResponseBody(name='body'),
}

async function orderBatchUpdateOrderStateWithOptions(request: OrderBatchUpdateOrderStateRequest, runtime: Util.RuntimeOptions): OrderBatchUpdateOrderStateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OrderBatchUpdateOrderState',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderBatchUpdateOrderState(request: OrderBatchUpdateOrderStateRequest): OrderBatchUpdateOrderStateResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderBatchUpdateOrderStateWithOptions(request, runtime);
}

model OrderCancelRequest {
  jwt?: string(name='Jwt'),
  orderId?: long(name='OrderId'),
}

model OrderCancelResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  result?: map[string]any(name='Result', description='对象实例。'),
}

model OrderCancelResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderCancelResponseBody(name='body'),
}

async function orderCancelWithOptions(request: OrderCancelRequest, runtime: Util.RuntimeOptions): OrderCancelResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.jwt)) {
    body['Jwt'] = request.jwt;
  }
  if (!Util.isUnset(request.orderId)) {
    body['OrderId'] = request.orderId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'OrderCancel',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderCancel(request: OrderCancelRequest): OrderCancelResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderCancelWithOptions(request, runtime);
}

model OrderCreateRequest {
  gender?: long(name='Gender', description='性别'),
  jwt?: string(name='Jwt'),
  photoPath?: string(name='PhotoPath', description='照片地址'),
}

model OrderCreateResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  result?: {
    orderId?: long(name='OrderId'),
  }(name='Result'),
}

model OrderCreateResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderCreateResponseBody(name='body'),
}

async function orderCreateWithOptions(request: OrderCreateRequest, runtime: Util.RuntimeOptions): OrderCreateResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.gender)) {
    body['Gender'] = request.gender;
  }
  if (!Util.isUnset(request.jwt)) {
    body['Jwt'] = request.jwt;
  }
  if (!Util.isUnset(request.photoPath)) {
    body['PhotoPath'] = request.photoPath;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'OrderCreate',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderCreate(request: OrderCreateRequest): OrderCreateResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderCreateWithOptions(request, runtime);
}

model OrderFindAllRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model OrderFindAllResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: map[string]any(name='ResultObj'),
  success?: boolean(name='Success'),
}

model OrderFindAllResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderFindAllResponseBody(name='body'),
}

async function orderFindAllWithOptions(request: OrderFindAllRequest, runtime: Util.RuntimeOptions): OrderFindAllResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OrderFindAll',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderFindAll(request: OrderFindAllRequest): OrderFindAllResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderFindAllWithOptions(request, runtime);
}

model OrderQueryByUserRequest {
  jwt?: string(name='Jwt'),
}

model OrderQueryByUserResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  result?: {
    content?: [ 
      {
        formatList?: {
          glb?: boolean(name='Glb'),
          jpg?: boolean(name='Jpg'),
          mp4?: boolean(name='Mp4'),
        }(name='FormatList'),
        gender?: string(name='Gender'),
        imagePath?: string(name='ImagePath'),
        modelPath?: string(name='ModelPath'),
        name?: string(name='Name'),
        orderId?: string(name='OrderId'),
      }
    ](name='Content'),
  }(name='Result'),
}

model OrderQueryByUserResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderQueryByUserResponseBody(name='body'),
}

async function orderQueryByUserWithOptions(request: OrderQueryByUserRequest, runtime: Util.RuntimeOptions): OrderQueryByUserResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.jwt)) {
    body['Jwt'] = request.jwt;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'OrderQueryByUser',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderQueryByUser(request: OrderQueryByUserRequest): OrderQueryByUserResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderQueryByUserWithOptions(request, runtime);
}

model OrderQueryOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model OrderQueryOneResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: map[string]any(name='ResultObj'),
  success?: boolean(name='Success'),
}

model OrderQueryOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderQueryOneResponseBody(name='body'),
}

async function orderQueryOneWithOptions(request: OrderQueryOneRequest, runtime: Util.RuntimeOptions): OrderQueryOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OrderQueryOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderQueryOne(request: OrderQueryOneRequest): OrderQueryOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderQueryOneWithOptions(request, runtime);
}

model OrderQueryOneAppRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model OrderQueryOneAppResponseBody = {
  async?: boolean(name='Async'),
  asyncToken?: string(name='AsyncToken'),
  code?: string(name='Code'),
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  resultObj?: {
    backExtInfo?: {
      backInfoMap?: map[string]any(name='BackInfoMap'),
    }(name='BackExtInfo'),
    backReason?: string(name='BackReason'),
    billTime?: string(name='BillTime'),
    bizType?: string(name='BizType'),
    cloudTbLongId?: long(name='CloudTbLongId'),
    cloudTbPhone?: string(name='CloudTbPhone'),
    cloudUserId?: long(name='CloudUserId'),
    createUser?: {
      aliyunUid?: string(name='AliyunUid'),
      aliyunUidType?: string(name='AliyunUidType'),
      delete?: boolean(name='Delete'),
      email?: string(name='Email'),
      ext?: string(name='Ext'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      parentUid?: string(name='ParentUid'),
      phone?: string(name='Phone'),
    }(name='CreateUser'),
    customerName?: string(name='CustomerName'),
    demandContent?: string(name='DemandContent'),
    enabled?: boolean(name='Enabled'),
    estimatedCost?: double(name='EstimatedCost'),
    expectedOnlineTime?: string(name='ExpectedOnlineTime'),
    extraInfo?: {
      checkRequirements?: string(name='CheckRequirements'),
      extInfoMap?: map[string]any(name='ExtInfoMap'),
      objectDescription?: string(name='ObjectDescription'),
      photoShowThingsCnt?: string(name='PhotoShowThingsCnt'),
      processRequirements?: string(name='ProcessRequirements'),
      uploadRequirements?: string(name='UploadRequirements'),
      videoNumber?: string(name='VideoNumber'),
    }(name='ExtraInfo'),
    feeState?: string(name='FeeState'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    id?: long(name='Id'),
    industry?: string(name='Industry'),
    isvUserMap?: map[string]any(name='IsvUserMap'),
    itemType?: string(name='ItemType'),
    orderName?: string(name='OrderName'),
    orderState?: string(name='OrderState'),
    outBizNo?: string(name='OutBizNo'),
    panoramaSize?: double(name='PanoramaSize'),
    photoAddress?: string(name='PhotoAddress'),
    photoCity?: string(name='PhotoCity'),
    photoContact?: [ 
      {
        email?: string(name='Email'),
        phone?: string(name='Phone'),
        username?: string(name='Username'),
      }
    ](name='PhotoContact'),
    photoEnvironment?: string(name='PhotoEnvironment'),
    photoFloorNum?: long(name='PhotoFloorNum'),
    photoProvince?: string(name='PhotoProvince'),
    photoSize?: double(name='PhotoSize'),
    photoTime?: string(name='PhotoTime'),
    platform?: string(name='Platform'),
    platformAccount?: string(name='PlatformAccount'),
    platformAccountType?: string(name='PlatformAccountType'),
    project?: {
      bizType?: string(name='BizType'),
      buildStatus?: string(name='BuildStatus'),
      creatorId?: long(name='CreatorId'),
      creatorName?: string(name='CreatorName'),
      extInfo?: map[string]any(name='ExtInfo'),
      functionStatus?: string(name='FunctionStatus'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      highmodelAssignedTime?: string(name='HighmodelAssignedTime'),
      id?: long(name='Id'),
      isvAssignedTime?: string(name='IsvAssignedTime'),
      latestPipelineUsageInstanceStatus?: map[string]any(name='LatestPipelineUsageInstanceStatus'),
      modelConfirmedTime?: string(name='ModelConfirmedTime'),
      orderId?: long(name='OrderId'),
      projectDescription?: string(name='ProjectDescription'),
      projectName?: string(name='ProjectName'),
      projectStatus?: string(name='ProjectStatus'),
      publishStatus?: string(name='PublishStatus'),
      recentBuildTime?: string(name='RecentBuildTime'),
      recentPublishTime?: string(name='RecentPublishTime'),
      uploadStatus?: string(name='UploadStatus'),
    }(name='Project'),
    scanUser?: {
      aliyunUid?: string(name='AliyunUid'),
      aliyunUidType?: string(name='AliyunUidType'),
      delete?: boolean(name='Delete'),
      email?: string(name='Email'),
      ext?: string(name='Ext'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      parentUid?: string(name='ParentUid'),
      phone?: string(name='Phone'),
    }(name='ScanUser'),
    specialRequirements?: string(name='SpecialRequirements'),
    vrLink?: string(name='VrLink'),
  }(name='ResultObj'),
  retry?: boolean(name='Retry'),
  success?: boolean(name='Success'),
  traceId?: string(name='TraceId'),
}

model OrderQueryOneAppResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderQueryOneAppResponseBody(name='body'),
}

async function orderQueryOneAppWithOptions(request: OrderQueryOneAppRequest, runtime: Util.RuntimeOptions): OrderQueryOneAppResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OrderQueryOneApp',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderQueryOneApp(request: OrderQueryOneAppRequest): OrderQueryOneAppResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderQueryOneAppWithOptions(request, runtime);
}

model OrderQueryStatusRequest {
  jwt?: string(name='Jwt'),
  orderId?: long(name='OrderId'),
}

model OrderQueryStatusResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  result?: {
    orderStatus?: string(name='OrderStatus'),
  }(name='Result'),
}

model OrderQueryStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderQueryStatusResponseBody(name='body'),
}

async function orderQueryStatusWithOptions(request: OrderQueryStatusRequest, runtime: Util.RuntimeOptions): OrderQueryStatusResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.jwt)) {
    body['Jwt'] = request.jwt;
  }
  if (!Util.isUnset(request.orderId)) {
    body['OrderId'] = request.orderId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'OrderQueryStatus',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderQueryStatus(request: OrderQueryStatusRequest): OrderQueryStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderQueryStatusWithOptions(request, runtime);
}

model OrderUpdateOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model OrderUpdateOneResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: map[string]any(name='ResultObj'),
  success?: boolean(name='Success'),
}

model OrderUpdateOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderUpdateOneResponseBody(name='body'),
}

async function orderUpdateOneWithOptions(request: OrderUpdateOneRequest, runtime: Util.RuntimeOptions): OrderUpdateOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OrderUpdateOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderUpdateOne(request: OrderUpdateOneRequest): OrderUpdateOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderUpdateOneWithOptions(request, runtime);
}

model PCDatasetCreateOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  body?: string(name='Body'),
  projectId?: long(name='ProjectId'),
}

model PCDatasetCreateOneResponseBody = {
  bizType?: string(name='BizType'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  gmtPublished?: string(name='GmtPublished'),
  id?: long(name='Id'),
  note?: {
    description?: string(name='Description'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    id?: long(name='Id'),
    name?: string(name='Name'),
  }(name='Note'),
  ossKey?: string(name='OssKey'),
  publishStatus?: string(name='PublishStatus'),
  requestId?: string(name='RequestId', description='Id of the request'),
  status?: string(name='Status'),
  typeId?: long(name='TypeId'),
}

model PCDatasetCreateOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: PCDatasetCreateOneResponseBody(name='body'),
}

async function pCDatasetCreateOneWithOptions(request: PCDatasetCreateOneRequest, runtime: Util.RuntimeOptions): PCDatasetCreateOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.body)) {
    query['Body'] = request.body;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PCDatasetCreateOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function pCDatasetCreateOne(request: PCDatasetCreateOneRequest): PCDatasetCreateOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return pCDatasetCreateOneWithOptions(request, runtime);
}

model PCUploadBuildRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model PCUploadBuildResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: map[string]any(name='ResultObj'),
  success?: boolean(name='Success'),
}

model PCUploadBuildResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: PCUploadBuildResponseBody(name='body'),
}

async function pCUploadBuildWithOptions(request: PCUploadBuildRequest, runtime: Util.RuntimeOptions): PCUploadBuildResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PCUploadBuild',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function pCUploadBuild(request: PCUploadBuildRequest): PCUploadBuildResponse {
  var runtime = new Util.RuntimeOptions{};
  return pCUploadBuildWithOptions(request, runtime);
}

model PCUploadPublishRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  datasetId?: long(name='DatasetId'),
  projectId?: long(name='ProjectId'),
}

model PCUploadPublishResponseBody = {
  requestId?: string(name='RequestId', description='Id of the request'),
  submit?: string(name='Submit'),
}

model PCUploadPublishResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: PCUploadPublishResponseBody(name='body'),
}

async function pCUploadPublishWithOptions(request: PCUploadPublishRequest, runtime: Util.RuntimeOptions): PCUploadPublishResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PCUploadPublish',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function pCUploadPublish(request: PCUploadPublishRequest): PCUploadPublishResponse {
  var runtime = new Util.RuntimeOptions{};
  return pCUploadPublishWithOptions(request, runtime);
}

model PipelineFindAllRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  code?: string(name='Code'),
  enabled?: boolean(name='Enabled'),
  exposed?: boolean(name='Exposed'),
  isRoot?: boolean(name='IsRoot'),
}

model PipelineFindAllResponseBody = {
  content?: string(name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: string(name='Last'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId', description='Id of the request'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model PipelineFindAllResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: PipelineFindAllResponseBody(name='body'),
}

async function pipelineFindAllWithOptions(request: PipelineFindAllRequest, runtime: Util.RuntimeOptions): PipelineFindAllResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.code)) {
    query['Code'] = request.code;
  }
  if (!Util.isUnset(request.enabled)) {
    query['Enabled'] = request.enabled;
  }
  if (!Util.isUnset(request.exposed)) {
    query['Exposed'] = request.exposed;
  }
  if (!Util.isUnset(request.isRoot)) {
    query['IsRoot'] = request.isRoot;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PipelineFindAll',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function pipelineFindAll(request: PipelineFindAllRequest): PipelineFindAllResponse {
  var runtime = new Util.RuntimeOptions{};
  return pipelineFindAllWithOptions(request, runtime);
}

model ProduceExpoNoticeRequest {
  bizType?: string(name='BizType', description='A short description of struct'),
  extInfo?: string(name='ExtInfo'),
  operationType?: string(name='OperationType'),
  userId?: long(name='UserId'),
}

model ProduceExpoNoticeResponseBody = {
  data?: map[string]any(name='Data'),
  error?: string(name='Error'),
  msgCode?: string(name='MsgCode'),
  msgInfo?: string(name='MsgInfo'),
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: boolean(name='Success'),
}

model ProduceExpoNoticeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ProduceExpoNoticeResponseBody(name='body'),
}

async function produceExpoNoticeWithOptions(request: ProduceExpoNoticeRequest, runtime: Util.RuntimeOptions): ProduceExpoNoticeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.extInfo)) {
    query['ExtInfo'] = request.extInfo;
  }
  if (!Util.isUnset(request.operationType)) {
    query['OperationType'] = request.operationType;
  }
  if (!Util.isUnset(request.userId)) {
    query['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ProduceExpoNotice',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function produceExpoNotice(request: ProduceExpoNoticeRequest): ProduceExpoNoticeResponse {
  var runtime = new Util.RuntimeOptions{};
  return produceExpoNoticeWithOptions(request, runtime);
}

model ProduceNoticeRequest {
  bizId?: string(name='BizId'),
  bizType?: string(name='BizType'),
  extInfo?: string(name='ExtInfo'),
  operationType?: string(name='OperationType'),
  userId?: long(name='UserId'),
}

model ProduceNoticeResponseBody = {
  data?: map[string]any(name='Data'),
  error?: string(name='Error'),
  msgCode?: string(name='MsgCode'),
  msgInfo?: string(name='MsgInfo'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ProduceNoticeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ProduceNoticeResponseBody(name='body'),
}

async function produceNoticeWithOptions(request: ProduceNoticeRequest, runtime: Util.RuntimeOptions): ProduceNoticeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizId)) {
    query['BizId'] = request.bizId;
  }
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.extInfo)) {
    query['ExtInfo'] = request.extInfo;
  }
  if (!Util.isUnset(request.operationType)) {
    query['OperationType'] = request.operationType;
  }
  if (!Util.isUnset(request.userId)) {
    query['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ProduceNotice',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function produceNotice(request: ProduceNoticeRequest): ProduceNoticeResponse {
  var runtime = new Util.RuntimeOptions{};
  return produceNoticeWithOptions(request, runtime);
}

model ProjectCreateOneAPPRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model ProjectCreateOneAPPResponseBody = {
  bizType?: string(name='BizType'),
  buildStatusInfo?: {
    endTime?: string(name='EndTime'),
    progress?: long(name='Progress'),
    startTime?: string(name='StartTime'),
    status?: string(name='Status'),
    tips?: string(name='Tips'),
  }(name='BuildStatusInfo'),
  code?: string(name='Code'),
  displayName?: string(name='DisplayName'),
  extInfo?: map[string]any(name='ExtInfo'),
  functionStatusInfo?: {
    endTime?: string(name='EndTime'),
    progress?: long(name='Progress'),
    startTime?: string(name='StartTime'),
    status?: string(name='Status'),
    tips?: string(name='Tips'),
  }(name='FunctionStatusInfo'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  highmodelAssignedTime?: string(name='HighmodelAssignedTime'),
  id?: long(name='Id'),
  isvAssignedTime?: string(name='IsvAssignedTime'),
  latestPipelineUsageInstance?: {
    APPENDPUBLISH?: string(name='APPENDPUBLISH'),
    HIGHMODELBUILD?: string(name='HIGHMODELBUILD'),
    MIRRORANNOTATION?: string(name='MIRRORANNOTATION'),
    MODELREBUILDPUB?: string(name='MODELREBUILDPUB'),
    MODELREPLACE?: string(name='MODELREPLACE'),
    MODELREPLACENODATASET?: string(name='MODELREPLACENODATASET'),
    OSSCOVER?: string(name='OSSCOVER'),
    PTZMODELREBUILDPUB?: string(name='PTZMODELREBUILDPUB'),
    PUBLISH?: string(name='PUBLISH'),
    REBUID?: string(name='REBUID'),
  }(name='LatestPipelineUsageInstance'),
  message?: string(name='Message'),
  modelConfirmedTime?: string(name='ModelConfirmedTime'),
  note?: {
    description?: string(name='Description'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    id?: long(name='Id'),
    name?: string(name='Name'),
  }(name='Note'),
  orderId?: long(name='OrderId'),
  projectGroupId?: string(name='ProjectGroupId'),
  projectSource?: string(name='ProjectSource'),
  projectStatus?: string(name='ProjectStatus'),
  publishStatusInfo?: {
    endTime?: string(name='EndTime'),
    progress?: long(name='Progress'),
    startTime?: string(name='StartTime'),
    status?: string(name='Status'),
    tips?: string(name='Tips'),
  }(name='PublishStatusInfo'),
  recentBuildTime?: string(name='RecentBuildTime'),
  requestId?: string(name='RequestId', description='Id of the request'),
  uploadStatusInfo?: {
    endTime?: string(name='EndTime'),
    progress?: long(name='Progress'),
    startTime?: string(name='StartTime'),
    status?: string(name='Status'),
    tips?: string(name='Tips'),
  }(name='UploadStatusInfo'),
}

model ProjectCreateOneAPPResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ProjectCreateOneAPPResponseBody(name='body'),
}

async function projectCreateOneAPPWithOptions(request: ProjectCreateOneAPPRequest, runtime: Util.RuntimeOptions): ProjectCreateOneAPPResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ProjectCreateOneAPP',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function projectCreateOneAPP(request: ProjectCreateOneAPPRequest): ProjectCreateOneAPPResponse {
  var runtime = new Util.RuntimeOptions{};
  return projectCreateOneAPPWithOptions(request, runtime);
}

model ProjectCreateOrUpdateExtInfoRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  extInfoStr?: string(name='ExtInfoStr'),
  projectId?: string(name='ProjectId'),
}

model ProjectCreateOrUpdateExtInfoResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: map[string]any(name='ResultObj'),
  success?: boolean(name='Success'),
}

model ProjectCreateOrUpdateExtInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ProjectCreateOrUpdateExtInfoResponseBody(name='body'),
}

async function projectCreateOrUpdateExtInfoWithOptions(request: ProjectCreateOrUpdateExtInfoRequest, runtime: Util.RuntimeOptions): ProjectCreateOrUpdateExtInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.extInfoStr)) {
    query['ExtInfoStr'] = request.extInfoStr;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ProjectCreateOrUpdateExtInfo',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function projectCreateOrUpdateExtInfo(request: ProjectCreateOrUpdateExtInfoRequest): ProjectCreateOrUpdateExtInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return projectCreateOrUpdateExtInfoWithOptions(request, runtime);
}

model ProjectCreateOrUpdateExtInfoAppRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  extInfoStr?: string(name='ExtInfoStr'),
  projectId?: string(name='ProjectId'),
}

model ProjectCreateOrUpdateExtInfoAppResponseBody = {
  code?: string(name='Code'),
  extInfo?: {
    FLOORPLANAREA?: string(name='FLOORPLANAREA'),
    ONLINEDNS?: string(name='ONLINEDNS'),
    STATUS?: string(name='STATUS'),
  }(name='ExtInfo'),
  message?: string(name='Message'),
  projectId?: long(name='ProjectId'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model ProjectCreateOrUpdateExtInfoAppResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ProjectCreateOrUpdateExtInfoAppResponseBody(name='body'),
}

async function projectCreateOrUpdateExtInfoAppWithOptions(request: ProjectCreateOrUpdateExtInfoAppRequest, runtime: Util.RuntimeOptions): ProjectCreateOrUpdateExtInfoAppResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.extInfoStr)) {
    query['ExtInfoStr'] = request.extInfoStr;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ProjectCreateOrUpdateExtInfoApp',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function projectCreateOrUpdateExtInfoApp(request: ProjectCreateOrUpdateExtInfoAppRequest): ProjectCreateOrUpdateExtInfoAppResponse {
  var runtime = new Util.RuntimeOptions{};
  return projectCreateOrUpdateExtInfoAppWithOptions(request, runtime);
}

model ProjectFindAllRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  jsonParams?: string(name='JsonParams'),
}

model ProjectFindAllResponseBody = {
  code?: string(name='Code'),
  content?: [ 
    {
      bizType?: string(name='BizType'),
      buildStatusInfo?: {
        endTime?: string(name='EndTime'),
        progress?: long(name='Progress'),
        startTime?: string(name='StartTime'),
        status?: string(name='Status'),
        tips?: string(name='Tips'),
      }(name='BuildStatusInfo'),
      customerName?: string(name='CustomerName'),
      displayName?: string(name='DisplayName'),
      extInfo?: {
        FLOORPLANAREA?: string(name='FLOORPLANAREA'),
        ONLINEDNS?: string(name='ONLINEDNS'),
        STATUS?: string(name='STATUS'),
      }(name='ExtInfo'),
      functionStatusInfo?: {
        endTime?: string(name='EndTime'),
        progress?: long(name='Progress'),
        startTime?: string(name='StartTime'),
        status?: string(name='Status'),
        tips?: string(name='Tips'),
      }(name='FunctionStatusInfo'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      highmodelAssignedTime?: string(name='HighmodelAssignedTime'),
      id?: long(name='Id'),
      isvAssignedTime?: string(name='IsvAssignedTime'),
      latestPipelineUsageInstance?: map[string]any(name='LatestPipelineUsageInstance'),
      modelConfirmedTime?: string(name='ModelConfirmedTime'),
      note?: {
        description?: string(name='Description'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: long(name='Id'),
        name?: string(name='Name'),
      }(name='Note'),
      orderId?: long(name='OrderId'),
      orderName?: string(name='OrderName'),
      photoAddress?: string(name='PhotoAddress'),
      photoContact?: [ 
        {
          email?: string(name='Email'),
          phone?: string(name='Phone'),
          userName?: string(name='UserName'),
        }
      ](name='PhotoContact'),
      projectGroupId?: string(name='ProjectGroupId'),
      projectSource?: string(name='ProjectSource'),
      projectStatus?: string(name='ProjectStatus'),
      publishStatusInfo?: {
        endTime?: string(name='EndTime'),
        progress?: long(name='Progress'),
        startTime?: string(name='StartTime'),
        status?: string(name='Status'),
        tips?: string(name='Tips'),
      }(name='PublishStatusInfo'),
      recentBuildTime?: string(name='RecentBuildTime'),
      uploadStatusInfo?: {
        endTime?: string(name='EndTime'),
        progress?: long(name='Progress'),
        startTime?: string(name='StartTime'),
        status?: string(name='Status'),
        tips?: string(name='Tips'),
      }(name='UploadStatusInfo'),
    }
  ](name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: boolean(name='Last'),
  message?: string(name='Message'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model ProjectFindAllResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ProjectFindAllResponseBody(name='body'),
}

async function projectFindAllWithOptions(request: ProjectFindAllRequest, runtime: Util.RuntimeOptions): ProjectFindAllResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.jsonParams)) {
    query['JsonParams'] = request.jsonParams;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ProjectFindAll',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function projectFindAll(request: ProjectFindAllRequest): ProjectFindAllResponse {
  var runtime = new Util.RuntimeOptions{};
  return projectFindAllWithOptions(request, runtime);
}

model ProjectFindUploadsRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  createdByCurrentUser?: boolean(name='CreatedByCurrentUser'),
  datasetId?: long(name='DatasetId'),
  live?: boolean(name='Live'),
}

model ProjectFindUploadsResponseBody = {
  content?: [ 
    {
      code?: string(name='Code'),
      datasetId?: long(name='DatasetId'),
      deviceKey?: string(name='DeviceKey'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      message?: string(name='Message'),
      progress?: long(name='Progress'),
      status?: string(name='Status'),
    }
  ](name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: boolean(name='Last'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId', description='Id of the request'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model ProjectFindUploadsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ProjectFindUploadsResponseBody(name='body'),
}

async function projectFindUploadsWithOptions(request: ProjectFindUploadsRequest, runtime: Util.RuntimeOptions): ProjectFindUploadsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.createdByCurrentUser)) {
    query['CreatedByCurrentUser'] = request.createdByCurrentUser;
  }
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.live)) {
    query['Live'] = request.live;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ProjectFindUploads',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function projectFindUploads(request: ProjectFindUploadsRequest): ProjectFindUploadsResponse {
  var runtime = new Util.RuntimeOptions{};
  return projectFindUploadsWithOptions(request, runtime);
}

model ProjectGetOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  projectId?: long(name='ProjectId'),
}

model ProjectGetOneResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: map[string]any(name='ResultObj'),
  success?: boolean(name='Success'),
}

model ProjectGetOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ProjectGetOneResponseBody(name='body'),
}

async function projectGetOneWithOptions(request: ProjectGetOneRequest, runtime: Util.RuntimeOptions): ProjectGetOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ProjectGetOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function projectGetOne(request: ProjectGetOneRequest): ProjectGetOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return projectGetOneWithOptions(request, runtime);
}

model ProjectGetOneAppRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  projectId?: long(name='ProjectId'),
}

model ProjectGetOneAppResponseBody = {
  bizType?: string(name='BizType'),
  buildStatusInfo?: {
    endTime?: string(name='EndTime'),
    progress?: long(name='Progress'),
    startTime?: string(name='StartTime'),
    status?: string(name='Status'),
    tips?: string(name='Tips'),
  }(name='BuildStatusInfo'),
  code?: string(name='Code'),
  displayName?: string(name='DisplayName'),
  extInfo?: {
    FLOORPLANAREA?: string(name='FLOORPLANAREA'),
    ONLINEDNS?: string(name='ONLINEDNS'),
    STATUS?: string(name='STATUS'),
  }(name='ExtInfo'),
  functionStatusInfo?: {
    endTime?: string(name='EndTime'),
    progress?: long(name='Progress'),
    startTime?: string(name='StartTime'),
    status?: string(name='Status'),
    tips?: string(name='Tips'),
  }(name='FunctionStatusInfo'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  highmodelAssignedTime?: string(name='HighmodelAssignedTime'),
  icon?: string(name='Icon'),
  id?: long(name='Id'),
  isvAssignedTime?: string(name='IsvAssignedTime'),
  latestPipelineUsageInstance?: map[string]any(name='LatestPipelineUsageInstance'),
  message?: string(name='Message'),
  modelConfirmedTime?: string(name='ModelConfirmedTime'),
  nickName?: string(name='NickName'),
  note?: {
    description?: string(name='Description'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    id?: long(name='Id'),
    name?: string(name='Name'),
  }(name='Note'),
  orderId?: long(name='OrderId'),
  projectGroupId?: string(name='ProjectGroupId'),
  projectSource?: string(name='ProjectSource'),
  projectStatus?: string(name='ProjectStatus'),
  publishStatusInfo?: {
    endTime?: string(name='EndTime'),
    progress?: long(name='Progress'),
    startTime?: string(name='StartTime'),
    status?: string(name='Status'),
    tips?: string(name='Tips'),
  }(name='PublishStatusInfo'),
  recentBuildTime?: string(name='RecentBuildTime'),
  requestId?: string(name='RequestId', description='Id of the request'),
  status?: string(name='Status'),
  thumbnail?: string(name='Thumbnail'),
  uploadStatusInfo?: {
    endTime?: string(name='EndTime'),
    progress?: long(name='Progress'),
    startTime?: string(name='StartTime'),
    status?: string(name='Status'),
    tips?: string(name='Tips'),
  }(name='UploadStatusInfo'),
}

model ProjectGetOneAppResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ProjectGetOneAppResponseBody(name='body'),
}

async function projectGetOneAppWithOptions(request: ProjectGetOneAppRequest, runtime: Util.RuntimeOptions): ProjectGetOneAppResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ProjectGetOneApp',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function projectGetOneApp(request: ProjectGetOneAppRequest): ProjectGetOneAppResponse {
  var runtime = new Util.RuntimeOptions{};
  return projectGetOneAppWithOptions(request, runtime);
}

model ProjectGetStatusAndOssRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model ProjectGetStatusAndOssResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  projectStatusAndOssResponseList?: [ 
    {
      datasetPublishStatus?: string(name='DatasetPublishStatus'),
      gmtPublished?: string(name='GmtPublished'),
      icon?: string(name='Icon'),
      name?: string(name='Name'),
      ossSts?: map[string]any(name='OssSts'),
      pipelineStatus?: string(name='PipelineStatus'),
      projectId?: long(name='ProjectId'),
    }
  ](name='ProjectStatusAndOssResponseList'),
  requestId?: string(name='RequestId'),
}

model ProjectGetStatusAndOssResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ProjectGetStatusAndOssResponseBody(name='body'),
}

async function projectGetStatusAndOssWithOptions(request: ProjectGetStatusAndOssRequest, runtime: Util.RuntimeOptions): ProjectGetStatusAndOssResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ProjectGetStatusAndOss',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function projectGetStatusAndOss(request: ProjectGetStatusAndOssRequest): ProjectGetStatusAndOssResponse {
  var runtime = new Util.RuntimeOptions{};
  return projectGetStatusAndOssWithOptions(request, runtime);
}

model ProjectSyncProjectStatusRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model ProjectSyncProjectStatusResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model ProjectSyncProjectStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ProjectSyncProjectStatusResponseBody(name='body'),
}

async function projectSyncProjectStatusWithOptions(request: ProjectSyncProjectStatusRequest, runtime: Util.RuntimeOptions): ProjectSyncProjectStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ProjectSyncProjectStatus',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function projectSyncProjectStatus(request: ProjectSyncProjectStatusRequest): ProjectSyncProjectStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return projectSyncProjectStatusWithOptions(request, runtime);
}

model PublishGalleryRequest {
  datasetId?: long(name='DatasetId'),
  tag?: string(name='Tag'),
  template?: string(name='Template'),
}

model PublishGalleryResponseBody = {
  data?: map[string]any(name='Data'),
  error?: string(name='Error'),
  msgCode?: string(name='MsgCode'),
  msgInfo?: string(name='MsgInfo'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model PublishGalleryResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: PublishGalleryResponseBody(name='body'),
}

async function publishGalleryWithOptions(request: PublishGalleryRequest, runtime: Util.RuntimeOptions): PublishGalleryResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.tag)) {
    query['Tag'] = request.tag;
  }
  if (!Util.isUnset(request.template)) {
    query['Template'] = request.template;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PublishGallery',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function publishGallery(request: PublishGalleryRequest): PublishGalleryResponse {
  var runtime = new Util.RuntimeOptions{};
  return publishGalleryWithOptions(request, runtime);
}

model PublishRealRequest {
  datasetId?: long(name='DatasetId', description='datasetId'),
  projectId?: long(name='ProjectId', description='projectId'),
  tag?: string(name='Tag', description='tag'),
}

model PublishRealResponseBody = {
  data?: string(name='Data', description='data'),
  error?: string(name='Error', description='error'),
  msgCode?: string(name='MsgCode', description='msgCode'),
  msgInfo?: string(name='MsgInfo', description='msgInfo'),
  requestId?: string(name='RequestId', description='traceId'),
  success?: boolean(name='Success', description='success'),
}

model PublishRealResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: PublishRealResponseBody(name='body'),
}

async function publishRealWithOptions(request: PublishRealRequest, runtime: Util.RuntimeOptions): PublishRealResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.datasetId)) {
    query['DatasetId'] = request.datasetId;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.tag)) {
    query['Tag'] = request.tag;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PublishReal',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function publishReal(request: PublishRealRequest): PublishRealResponse {
  var runtime = new Util.RuntimeOptions{};
  return publishRealWithOptions(request, runtime);
}

model QueryAccountLabelRequest {
  labelSeries?: string(name='LabelSeries'),
  PK?: long(name='PK'),
  token?: string(name='Token', description='token 通过聚宝盆申请，预发环境label 查询必须使用'),
}

model QueryAccountLabelResponseBody = {
  code?: string(name='Code'),
  count?: int32(name='Count'),
  data?: [ 
    {
      label?: string(name='Label'),
      labelSeries?: string(name='LabelSeries'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
  success?: boolean(name='Success'),
}

model QueryAccountLabelResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryAccountLabelResponseBody(name='body'),
}

async function queryAccountLabelWithOptions(request: QueryAccountLabelRequest, runtime: Util.RuntimeOptions): QueryAccountLabelResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.labelSeries)) {
    query['LabelSeries'] = request.labelSeries;
  }
  if (!Util.isUnset(request.PK)) {
    query['PK'] = request.PK;
  }
  if (!Util.isUnset(request.token)) {
    query['Token'] = request.token;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryAccountLabel',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryAccountLabel(request: QueryAccountLabelRequest): QueryAccountLabelResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryAccountLabelWithOptions(request, runtime);
}

model QueryBizLogByOpTypeAndTimeRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model QueryBizLogByOpTypeAndTimeResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMsg?: string(name='ErrorMsg'),
  requestId?: string(name='RequestId', description='Id of the request'),
  resultObj?: [  map[string]any ](name='ResultObj'),
  success?: string(name='Success'),
}

model QueryBizLogByOpTypeAndTimeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryBizLogByOpTypeAndTimeResponseBody(name='body'),
}

async function queryBizLogByOpTypeAndTimeWithOptions(request: QueryBizLogByOpTypeAndTimeRequest, runtime: Util.RuntimeOptions): QueryBizLogByOpTypeAndTimeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryBizLogByOpTypeAndTime',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryBizLogByOpTypeAndTime(request: QueryBizLogByOpTypeAndTimeRequest): QueryBizLogByOpTypeAndTimeResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryBizLogByOpTypeAndTimeWithOptions(request, runtime);
}

model QueryQRCodeInfoRequest {
  SId?: string(name='SId', description='sId'),
}

model QueryQRCodeInfoResponseBody = {
  data?: string(name='Data', description='data'),
  error?: string(name='Error', description='error'),
  msgCode?: string(name='MsgCode', description='msgCode'),
  msgInfo?: string(name='MsgInfo', description='msgInfo'),
  requestId?: string(name='RequestId', description='traceId'),
  success?: boolean(name='Success', description='success'),
}

model QueryQRCodeInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryQRCodeInfoResponseBody(name='body'),
}

async function queryQRCodeInfoWithOptions(request: QueryQRCodeInfoRequest, runtime: Util.RuntimeOptions): QueryQRCodeInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.SId)) {
    query['SId'] = request.SId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryQRCodeInfo',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryQRCodeInfo(request: QueryQRCodeInfoRequest): QueryQRCodeInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryQRCodeInfoWithOptions(request, runtime);
}

model ScanDataCreateProjectRequest {
  bizOrderNo?: string(name='BizOrderNo', description='业务幂等编号'),
  createScanUserDataRequest?: {
    userMobNum?: string(name='UserMobNum', description='会员类型对应的手机号码'),
    userNick?: string(name='UserNick', description='会员类型对应的昵称'),
    userType?: string(name='UserType', description='目前只支持TB一种类型'),
  }(name='CreateScanUserDataRequest', description='createScanUserDataRequest'),
  projectDesc?: string(name='ProjectDesc', description='项目描述'),
  projectName?: string(name='ProjectName', description='单个人下不允许出现相同项目名'),
  source?: string(name='Source', description='目前只支持3VJIA'),
}

model ScanDataCreateProjectShrinkRequest {
  bizOrderNo?: string(name='BizOrderNo', description='业务幂等编号'),
  createScanUserDataRequestShrink?: string(name='CreateScanUserDataRequest', description='createScanUserDataRequest'),
  projectDesc?: string(name='ProjectDesc', description='项目描述'),
  projectName?: string(name='ProjectName', description='单个人下不允许出现相同项目名'),
  source?: string(name='Source', description='目前只支持3VJIA'),
}

model ScanDataCreateProjectResponseBody = {
  async?: boolean(name='Async', description='async'),
  asyncToken?: string(name='AsyncToken', description='asyncToken'),
  errorCode?: string(name='ErrorCode', description='errorCode'),
  errorMsg?: string(name='ErrorMsg', description='errorMsg'),
  projectId?: long(name='ProjectId', description='resultObj'),
  requestId?: string(name='RequestId', description='traceId'),
  retry?: boolean(name='Retry', description='retry'),
  success?: boolean(name='Success', description='success'),
}

model ScanDataCreateProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ScanDataCreateProjectResponseBody(name='body'),
}

async function scanDataCreateProjectWithOptions(tmpReq: ScanDataCreateProjectRequest, runtime: Util.RuntimeOptions): ScanDataCreateProjectResponse {
  Util.validateModel(tmpReq);
  var request = new ScanDataCreateProjectShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.createScanUserDataRequest)) {
    request.createScanUserDataRequestShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.createScanUserDataRequest, 'CreateScanUserDataRequest', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.bizOrderNo)) {
    query['BizOrderNo'] = request.bizOrderNo;
  }
  if (!Util.isUnset(request.createScanUserDataRequestShrink)) {
    query['CreateScanUserDataRequest'] = request.createScanUserDataRequestShrink;
  }
  if (!Util.isUnset(request.projectDesc)) {
    query['ProjectDesc'] = request.projectDesc;
  }
  if (!Util.isUnset(request.projectName)) {
    query['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.source)) {
    query['Source'] = request.source;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ScanDataCreateProject',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function scanDataCreateProject(request: ScanDataCreateProjectRequest): ScanDataCreateProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return scanDataCreateProjectWithOptions(request, runtime);
}

model ScanDataQueryProjectRequest {
  bizOrderNo?: string(name='BizOrderNo', description='业务幂等ID，用于防止重复请求，写操作必传'),
  projectId?: long(name='ProjectId', description='查询的项目ID'),
  source?: string(name='Source', description='数据源，目前只有3VJIA，需要新增请联系接口owner'),
}

model ScanDataQueryProjectResponseBody = {
  async?: boolean(name='Async', description='async'),
  asyncToken?: string(name='AsyncToken', description='asyncToken'),
  errorCode?: string(name='ErrorCode', description='errorCode'),
  errorMsg?: string(name='ErrorMsg', description='errorMsg'),
  requestId?: string(name='RequestId', description='traceId'),
  resultObj?: map[string]any(name='ResultObj', description='resultObj'),
  retry?: boolean(name='Retry', description='retry'),
  success?: boolean(name='Success', description='success'),
}

model ScanDataQueryProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ScanDataQueryProjectResponseBody(name='body'),
}

async function scanDataQueryProjectWithOptions(request: ScanDataQueryProjectRequest, runtime: Util.RuntimeOptions): ScanDataQueryProjectResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ScanDataQueryProject',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function scanDataQueryProject(request: ScanDataQueryProjectRequest): ScanDataQueryProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return scanDataQueryProjectWithOptions(request, runtime);
}

model ScanDataRemoveRoleRequest {
  bizOrderNo?: string(name='BizOrderNo', description='业务幂等编号，用于幂等处理'),
  projectId?: long(name='ProjectId', description='移除角色的项目ID，必须是开放平台图对应source创建的项目'),
  removeUserDataRequest?: {
    userMobNum?: string(name='UserMobNum', description='会员手机号码'),
    userNick?: string(name='UserNick', description='会员昵称'),
    userType?: string(name='UserType', description='会员类型，目前只支持TB淘宝'),
  }(name='RemoveUserDataRequest', description='removeUserDataRequest'),
  roleName?: string(name='RoleName', description='移除角色名称，本次只支持PROJECT_MANAGER'),
  source?: string(name='Source', description='数据请求来源，目前只支持广州三维家3VJIA'),
}

model ScanDataRemoveRoleShrinkRequest {
  bizOrderNo?: string(name='BizOrderNo', description='业务幂等编号，用于幂等处理'),
  projectId?: long(name='ProjectId', description='移除角色的项目ID，必须是开放平台图对应source创建的项目'),
  removeUserDataRequestShrink?: string(name='RemoveUserDataRequest', description='removeUserDataRequest'),
  roleName?: string(name='RoleName', description='移除角色名称，本次只支持PROJECT_MANAGER'),
  source?: string(name='Source', description='数据请求来源，目前只支持广州三维家3VJIA'),
}

model ScanDataRemoveRoleResponseBody = {
  async?: boolean(name='Async', description='async'),
  asyncToken?: string(name='AsyncToken', description='asyncToken'),
  errorCode?: string(name='ErrorCode', description='errorCode'),
  errorMsg?: string(name='ErrorMsg', description='errorMsg'),
  projectId?: long(name='ProjectId', description='resultObj'),
  requestId?: string(name='RequestId', description='traceId'),
  retry?: boolean(name='Retry', description='retry'),
  success?: boolean(name='Success', description='success'),
}

model ScanDataRemoveRoleResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ScanDataRemoveRoleResponseBody(name='body'),
}

async function scanDataRemoveRoleWithOptions(tmpReq: ScanDataRemoveRoleRequest, runtime: Util.RuntimeOptions): ScanDataRemoveRoleResponse {
  Util.validateModel(tmpReq);
  var request = new ScanDataRemoveRoleShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.removeUserDataRequest)) {
    request.removeUserDataRequestShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.removeUserDataRequest, 'RemoveUserDataRequest', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.bizOrderNo)) {
    query['BizOrderNo'] = request.bizOrderNo;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.removeUserDataRequestShrink)) {
    query['RemoveUserDataRequest'] = request.removeUserDataRequestShrink;
  }
  if (!Util.isUnset(request.roleName)) {
    query['RoleName'] = request.roleName;
  }
  if (!Util.isUnset(request.source)) {
    query['Source'] = request.source;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ScanDataRemoveRole',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function scanDataRemoveRole(request: ScanDataRemoveRoleRequest): ScanDataRemoveRoleResponse {
  var runtime = new Util.RuntimeOptions{};
  return scanDataRemoveRoleWithOptions(request, runtime);
}

model ScanDataShareProjectRequest {
  bizOrderNo?: string(name='BizOrderNo', description='业务幂等ID，用于防止重复请求，写操作必传'),
  projectId?: long(name='ProjectId', description='需要分享的项目ID'),
  roleName?: string(name='RoleName', description='权限角色名，目前只支持项目管理员（PROJECT_MANAGER）'),
  shareUserDataRequest?: {
    userMobNum?: string(name='UserMobNum', description='分享用户的手机号码'),
    userNick?: string(name='UserNick', description='分享用户的昵称'),
    userType?: string(name='UserType', description='分享用户的会员类型，目前只支持淘宝TB'),
  }(name='ShareUserDataRequest', description='shareUserDataRequest'),
  source?: string(name='Source', description='对应数据源，目前仅支持广州三维家，需要新增源需要和接口负责人沟通并添加'),
}

model ScanDataShareProjectShrinkRequest {
  bizOrderNo?: string(name='BizOrderNo', description='业务幂等ID，用于防止重复请求，写操作必传'),
  projectId?: long(name='ProjectId', description='需要分享的项目ID'),
  roleName?: string(name='RoleName', description='权限角色名，目前只支持项目管理员（PROJECT_MANAGER）'),
  shareUserDataRequestShrink?: string(name='ShareUserDataRequest', description='shareUserDataRequest'),
  source?: string(name='Source', description='对应数据源，目前仅支持广州三维家，需要新增源需要和接口负责人沟通并添加'),
}

model ScanDataShareProjectResponseBody = {
  async?: boolean(name='Async', description='async'),
  asyncToken?: string(name='AsyncToken', description='asyncToken'),
  errorCode?: string(name='ErrorCode', description='errorCode'),
  errorMsg?: string(name='ErrorMsg', description='errorMsg'),
  projectId?: long(name='ProjectId', description='resultObj'),
  requestId?: string(name='RequestId', description='traceId'),
  retry?: boolean(name='Retry', description='retry'),
  success?: boolean(name='Success', description='success'),
}

model ScanDataShareProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ScanDataShareProjectResponseBody(name='body'),
}

async function scanDataShareProjectWithOptions(tmpReq: ScanDataShareProjectRequest, runtime: Util.RuntimeOptions): ScanDataShareProjectResponse {
  Util.validateModel(tmpReq);
  var request = new ScanDataShareProjectShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.shareUserDataRequest)) {
    request.shareUserDataRequestShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.shareUserDataRequest, 'ShareUserDataRequest', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.bizOrderNo)) {
    query['BizOrderNo'] = request.bizOrderNo;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.roleName)) {
    query['RoleName'] = request.roleName;
  }
  if (!Util.isUnset(request.shareUserDataRequestShrink)) {
    query['ShareUserDataRequest'] = request.shareUserDataRequestShrink;
  }
  if (!Util.isUnset(request.source)) {
    query['Source'] = request.source;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ScanDataShareProject',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function scanDataShareProject(request: ScanDataShareProjectRequest): ScanDataShareProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return scanDataShareProjectWithOptions(request, runtime);
}

model ScanDataUpdateProjectRequest {
  bizOrderNo?: string(name='BizOrderNo', description='业务幂等ID，用于防止重复请求，写操作必传'),
  projectDesc?: string(name='ProjectDesc', description='更新的项目描述信息'),
  projectId?: long(name='ProjectId', description='项目ID'),
  projectName?: string(name='ProjectName', description='项目名称'),
  source?: string(name='Source', description='对应数据源，目前仅支持广州三维家，需要新增源需要和接口负责人沟通并添加'),
  userMobNum?: string(name='UserMobNum', description='用户手机号码'),
  userNick?: string(name='UserNick', description='用户昵称'),
  userType?: string(name='UserType', description='用户会员类型，目前只支持TB淘宝'),
}

model ScanDataUpdateProjectResponseBody = {
  async?: boolean(name='Async', description='async'),
  asyncToken?: string(name='AsyncToken', description='asyncToken'),
  errorCode?: string(name='ErrorCode', description='errorCode'),
  errorMsg?: string(name='ErrorMsg', description='errorMsg'),
  projectId?: long(name='ProjectId', description='resultObj'),
  requestId?: string(name='RequestId', description='traceId'),
  retry?: boolean(name='Retry', description='retry'),
  success?: boolean(name='Success', description='success'),
}

model ScanDataUpdateProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ScanDataUpdateProjectResponseBody(name='body'),
}

async function scanDataUpdateProjectWithOptions(request: ScanDataUpdateProjectRequest, runtime: Util.RuntimeOptions): ScanDataUpdateProjectResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizOrderNo)) {
    query['BizOrderNo'] = request.bizOrderNo;
  }
  if (!Util.isUnset(request.projectDesc)) {
    query['ProjectDesc'] = request.projectDesc;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    query['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.source)) {
    query['Source'] = request.source;
  }
  if (!Util.isUnset(request.userMobNum)) {
    query['UserMobNum'] = request.userMobNum;
  }
  if (!Util.isUnset(request.userNick)) {
    query['UserNick'] = request.userNick;
  }
  if (!Util.isUnset(request.userType)) {
    query['UserType'] = request.userType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ScanDataUpdateProject',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function scanDataUpdateProject(request: ScanDataUpdateProjectRequest): ScanDataUpdateProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return scanDataUpdateProjectWithOptions(request, runtime);
}

model SpiltBimDrawingRequest {
  drawingId?: long(name='DrawingId', description='A short description of struct'),
  taskId?: long(name='TaskId'),
}

model SpiltBimDrawingResponseBody = {
  datas?: boolean(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SpiltBimDrawingResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SpiltBimDrawingResponseBody(name='body'),
}

async function spiltBimDrawingWithOptions(request: SpiltBimDrawingRequest, runtime: Util.RuntimeOptions): SpiltBimDrawingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.drawingId)) {
    query['DrawingId'] = request.drawingId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SpiltBimDrawing',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function spiltBimDrawing(request: SpiltBimDrawingRequest): SpiltBimDrawingResponse {
  var runtime = new Util.RuntimeOptions{};
  return spiltBimDrawingWithOptions(request, runtime);
}

model TestPopParamsResponseBody = {
  data?: string(name='Data'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model TestPopParamsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: TestPopParamsResponseBody(name='body'),
}

async function testPopParamsWithOptions(runtime: Util.RuntimeOptions): TestPopParamsResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'TestPopParams',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function testPopParams(): TestPopParamsResponse {
  var runtime = new Util.RuntimeOptions{};
  return testPopParamsWithOptions(runtime);
}

model TransTextToAudioRequest {
  text?: string(name='Text', description='text'),
}

model TransTextToAudioResponseBody = {
  data?: string(name='Data', description='data'),
  error?: string(name='Error', description='error'),
  msgCode?: string(name='MsgCode', description='msgCode'),
  msgInfo?: string(name='MsgInfo', description='msgInfo'),
  requestId?: string(name='RequestId', description='traceId'),
  success?: boolean(name='Success', description='success'),
}

model TransTextToAudioResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: TransTextToAudioResponseBody(name='body'),
}

async function transTextToAudioWithOptions(request: TransTextToAudioRequest, runtime: Util.RuntimeOptions): TransTextToAudioResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.text)) {
    body['Text'] = request.text;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'TransTextToAudio',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function transTextToAudio(request: TransTextToAudioRequest): TransTextToAudioResponse {
  var runtime = new Util.RuntimeOptions{};
  return transTextToAudioWithOptions(request, runtime);
}

model UpdateBimFragmentRequest {
  buildingNo?: string(name='BuildingNo', description='楼栋号'),
  coordinates?: [[ float ]  ](name='Coordinates'),
  drawingId?: long(name='DrawingId', description='标准图纸Id'),
  floorInfo?: {
    floorName?: string(name='FloorName'),
    floorNum?: string(name='FloorNum'),
  }(name='FloorInfo'),
  id?: long(name='Id', description='归类id'),
  selectionMode?: string(name='SelectionMode', description='选择方式'),
  subType?: string(name='SubType', description='子类型'),
  suffix?: string(name='Suffix', description='后缀'),
  taskId?: long(name='TaskId'),
  type?: string(name='Type', description='类型'),
}

model UpdateBimFragmentShrinkRequest {
  buildingNo?: string(name='BuildingNo', description='楼栋号'),
  coordinatesShrink?: string(name='Coordinates'),
  drawingId?: long(name='DrawingId', description='标准图纸Id'),
  floorInfoShrink?: string(name='FloorInfo'),
  id?: long(name='Id', description='归类id'),
  selectionMode?: string(name='SelectionMode', description='选择方式'),
  subType?: string(name='SubType', description='子类型'),
  suffix?: string(name='Suffix', description='后缀'),
  taskId?: long(name='TaskId'),
  type?: string(name='Type', description='类型'),
}

model UpdateBimFragmentResponseBody = {
  datas?: {
    drawingId?: long(name='DrawingId'),
    drawingMode?: string(name='DrawingMode'),
    id?: long(name='Id'),
  }(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateBimFragmentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateBimFragmentResponseBody(name='body'),
}

async function updateBimFragmentWithOptions(tmpReq: UpdateBimFragmentRequest, runtime: Util.RuntimeOptions): UpdateBimFragmentResponse {
  Util.validateModel(tmpReq);
  var request = new UpdateBimFragmentShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.coordinates)) {
    request.coordinatesShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.coordinates, 'Coordinates', 'json');
  }
  if (!Util.isUnset(tmpReq.floorInfo)) {
    request.floorInfoShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.floorInfo, 'FloorInfo', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.buildingNo)) {
    query['BuildingNo'] = request.buildingNo;
  }
  if (!Util.isUnset(request.coordinatesShrink)) {
    query['Coordinates'] = request.coordinatesShrink;
  }
  if (!Util.isUnset(request.drawingId)) {
    query['DrawingId'] = request.drawingId;
  }
  if (!Util.isUnset(request.floorInfoShrink)) {
    query['FloorInfo'] = request.floorInfoShrink;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.selectionMode)) {
    query['SelectionMode'] = request.selectionMode;
  }
  if (!Util.isUnset(request.subType)) {
    query['SubType'] = request.subType;
  }
  if (!Util.isUnset(request.suffix)) {
    query['Suffix'] = request.suffix;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBimFragment',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBimFragment(request: UpdateBimFragmentRequest): UpdateBimFragmentResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBimFragmentWithOptions(request, runtime);
}

model UpdateBimModelConfigRequest {
  beamHeight?: long(name='BeamHeight', description='梁高'),
  beamMode?: long(name='BeamMode', description='梁模式'),
  beamOffset?: long(name='BeamOffset', description='梁偏移'),
  doorHeight?: long(name='DoorHeight', description='门高'),
  doorOffset?: long(name='DoorOffset', description='门偏移'),
  id?: long(name='Id'),
  roomMode?: long(name='RoomMode', description='房间模式'),
  slabMode?: long(name='SlabMode', description='板模式'),
  slabThickness?: long(name='SlabThickness', description='板厚度'),
  taskId?: long(name='TaskId', description='任务id'),
  windowHeight?: long(name='WindowHeight', description='窗高'),
  windowOffset?: long(name='WindowOffset', description='窗偏移'),
}

model UpdateBimModelConfigResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateBimModelConfigResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateBimModelConfigResponseBody(name='body'),
}

async function updateBimModelConfigWithOptions(request: UpdateBimModelConfigRequest, runtime: Util.RuntimeOptions): UpdateBimModelConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.beamHeight)) {
    query['BeamHeight'] = request.beamHeight;
  }
  if (!Util.isUnset(request.beamMode)) {
    query['BeamMode'] = request.beamMode;
  }
  if (!Util.isUnset(request.beamOffset)) {
    query['BeamOffset'] = request.beamOffset;
  }
  if (!Util.isUnset(request.doorHeight)) {
    query['DoorHeight'] = request.doorHeight;
  }
  if (!Util.isUnset(request.doorOffset)) {
    query['DoorOffset'] = request.doorOffset;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.roomMode)) {
    query['RoomMode'] = request.roomMode;
  }
  if (!Util.isUnset(request.slabMode)) {
    query['SlabMode'] = request.slabMode;
  }
  if (!Util.isUnset(request.slabThickness)) {
    query['SlabThickness'] = request.slabThickness;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.windowHeight)) {
    query['WindowHeight'] = request.windowHeight;
  }
  if (!Util.isUnset(request.windowOffset)) {
    query['WindowOffset'] = request.windowOffset;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBimModelConfig',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBimModelConfig(request: UpdateBimModelConfigRequest): UpdateBimModelConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBimModelConfigWithOptions(request, runtime);
}

model UpdateBimProjectDrawFilesRequest {
  architectureFiles?: [ 
    {
      name?: string(name='Name'),
      path?: string(name='Path'),
    }
  ](name='ArchitectureFiles', description='建筑'),
  structureFiles?: [ 
    {
      name?: string(name='Name'),
      path?: string(name='Path'),
    }
  ](name='StructureFiles', description='结构'),
  taskId?: long(name='TaskId', description='任务id'),
}

model UpdateBimProjectDrawFilesShrinkRequest {
  architectureFilesShrink?: string(name='ArchitectureFiles', description='建筑'),
  structureFilesShrink?: string(name='StructureFiles', description='结构'),
  taskId?: long(name='TaskId', description='任务id'),
}

model UpdateBimProjectDrawFilesResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateBimProjectDrawFilesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateBimProjectDrawFilesResponseBody(name='body'),
}

async function updateBimProjectDrawFilesWithOptions(tmpReq: UpdateBimProjectDrawFilesRequest, runtime: Util.RuntimeOptions): UpdateBimProjectDrawFilesResponse {
  Util.validateModel(tmpReq);
  var request = new UpdateBimProjectDrawFilesShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.architectureFiles)) {
    request.architectureFilesShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.architectureFiles, 'ArchitectureFiles', 'json');
  }
  if (!Util.isUnset(tmpReq.structureFiles)) {
    request.structureFilesShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.structureFiles, 'StructureFiles', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.architectureFilesShrink)) {
    query['ArchitectureFiles'] = request.architectureFilesShrink;
  }
  if (!Util.isUnset(request.structureFilesShrink)) {
    query['StructureFiles'] = request.structureFilesShrink;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBimProjectDrawFiles',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBimProjectDrawFiles(request: UpdateBimProjectDrawFilesRequest): UpdateBimProjectDrawFilesResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBimProjectDrawFilesWithOptions(request, runtime);
}

model UpdateBimStandardDwInfoRequest {
  data?: [  map[string]any ](name='Data'),
  keys?: [ string ](name='Keys'),
  standardId?: long(name='StandardId'),
  taskId?: long(name='TaskId', description='任务id'),
}

model UpdateBimStandardDwInfoShrinkRequest {
  dataShrink?: string(name='Data'),
  keysShrink?: string(name='Keys'),
  standardId?: long(name='StandardId'),
  taskId?: long(name='TaskId', description='任务id'),
}

model UpdateBimStandardDwInfoResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateBimStandardDwInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateBimStandardDwInfoResponseBody(name='body'),
}

async function updateBimStandardDwInfoWithOptions(tmpReq: UpdateBimStandardDwInfoRequest, runtime: Util.RuntimeOptions): UpdateBimStandardDwInfoResponse {
  Util.validateModel(tmpReq);
  var request = new UpdateBimStandardDwInfoShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.data)) {
    request.dataShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.data, 'Data', 'json');
  }
  if (!Util.isUnset(tmpReq.keys)) {
    request.keysShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.keys, 'Keys', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.dataShrink)) {
    query['Data'] = request.dataShrink;
  }
  if (!Util.isUnset(request.keysShrink)) {
    query['Keys'] = request.keysShrink;
  }
  if (!Util.isUnset(request.standardId)) {
    query['StandardId'] = request.standardId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBimStandardDwInfo',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBimStandardDwInfo(request: UpdateBimStandardDwInfoRequest): UpdateBimStandardDwInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBimStandardDwInfoWithOptions(request, runtime);
}

model UpdateBimStandardElevationRequest {
  floors?: [  map[string]any ](name='Floors'),
  mode?: string(name='Mode'),
  standardId?: long(name='StandardId'),
  taskId?: long(name='TaskId', description='任务id'),
  terraceHeight?: double(name='TerraceHeight'),
}

model UpdateBimStandardElevationShrinkRequest {
  floorsShrink?: string(name='Floors'),
  mode?: string(name='Mode'),
  standardId?: long(name='StandardId'),
  taskId?: long(name='TaskId', description='任务id'),
  terraceHeight?: double(name='TerraceHeight'),
}

model UpdateBimStandardElevationResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateBimStandardElevationResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateBimStandardElevationResponseBody(name='body'),
}

async function updateBimStandardElevationWithOptions(tmpReq: UpdateBimStandardElevationRequest, runtime: Util.RuntimeOptions): UpdateBimStandardElevationResponse {
  Util.validateModel(tmpReq);
  var request = new UpdateBimStandardElevationShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.floors)) {
    request.floorsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.floors, 'Floors', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.floorsShrink)) {
    query['Floors'] = request.floorsShrink;
  }
  if (!Util.isUnset(request.mode)) {
    query['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.standardId)) {
    query['StandardId'] = request.standardId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.terraceHeight)) {
    query['TerraceHeight'] = request.terraceHeight;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBimStandardElevation',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBimStandardElevation(request: UpdateBimStandardElevationRequest): UpdateBimStandardElevationResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBimStandardElevationWithOptions(request, runtime);
}

model UpdateBimStandardSlabInfoRequest {
  legends?: [ 
    {
      elevationHeight?: string(name='ElevationHeight'),
      elevationMode?: string(name='ElevationMode'),
      elevationOperator?: string(name='ElevationOperator'),
      patternName?: string(name='PatternName'),
      picture?: string(name='Picture'),
      thickness?: long(name='Thickness'),
    }
  ](name='Legends'),
  rootDir?: string(name='RootDir'),
  standardId?: long(name='StandardId'),
  taskId?: long(name='TaskId', description='任务id'),
  thickness?: long(name='Thickness'),
}

model UpdateBimStandardSlabInfoShrinkRequest {
  legendsShrink?: string(name='Legends'),
  rootDir?: string(name='RootDir'),
  standardId?: long(name='StandardId'),
  taskId?: long(name='TaskId', description='任务id'),
  thickness?: long(name='Thickness'),
}

model UpdateBimStandardSlabInfoResponseBody = {
  datas?: long(name='Datas'),
  errCode?: long(name='ErrCode'),
  errMsg?: string(name='ErrMsg'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateBimStandardSlabInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateBimStandardSlabInfoResponseBody(name='body'),
}

async function updateBimStandardSlabInfoWithOptions(tmpReq: UpdateBimStandardSlabInfoRequest, runtime: Util.RuntimeOptions): UpdateBimStandardSlabInfoResponse {
  Util.validateModel(tmpReq);
  var request = new UpdateBimStandardSlabInfoShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.legends)) {
    request.legendsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.legends, 'Legends', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.legendsShrink)) {
    query['Legends'] = request.legendsShrink;
  }
  if (!Util.isUnset(request.rootDir)) {
    query['RootDir'] = request.rootDir;
  }
  if (!Util.isUnset(request.standardId)) {
    query['StandardId'] = request.standardId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.thickness)) {
    query['Thickness'] = request.thickness;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBimStandardSlabInfo',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBimStandardSlabInfo(request: UpdateBimStandardSlabInfoRequest): UpdateBimStandardSlabInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBimStandardSlabInfoWithOptions(request, runtime);
}

model UpdateNoteRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
  projectId?: long(name='ProjectId'),
}

model UpdateNoteResponseBody = {
  code?: string(name='Code'),
  description?: string(name='Description'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  message?: string(name='Message'),
  name?: string(name='Name'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model UpdateNoteResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateNoteResponseBody(name='body'),
}

async function updateNoteWithOptions(request: UpdateNoteRequest, runtime: Util.RuntimeOptions): UpdateNoteResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  if (!Util.isUnset(request.projectId)) {
    query['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateNote',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateNote(request: UpdateNoteRequest): UpdateNoteResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateNoteWithOptions(request, runtime);
}

model UpdateUserRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model UpdateUserResponseBody = {
  companyId?: long(name='CompanyId'),
  companyName?: string(name='CompanyName'),
  email?: string(name='Email'),
  ext1?: string(name='Ext1'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  name?: string(name='Name'),
  phone?: string(name='Phone'),
  requestId?: string(name='RequestId', description='Id of the request'),
  status?: string(name='Status'),
}

model UpdateUserResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateUserResponseBody(name='body'),
}

async function updateUserWithOptions(request: UpdateUserRequest, runtime: Util.RuntimeOptions): UpdateUserResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateUser',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateUser(request: UpdateUserRequest): UpdateUserResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateUserWithOptions(request, runtime);
}

model UserFindAllRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  params?: string(name='Params'),
}

model UserFindAllResponseBody = {
  content?: [ 
    {
      aliyunAccount?: string(name='AliyunAccount'),
      aliyunUid?: string(name='AliyunUid'),
      aliyunUidType?: string(name='AliyunUidType'),
      companyId?: long(name='CompanyId'),
      companyName?: string(name='CompanyName'),
      email?: string(name='Email'),
      ext1?: string(name='Ext1'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      parentUid?: string(name='ParentUid'),
      phone?: string(name='Phone'),
      roles?: [ 
        {
          code?: string(name='Code'),
          companyId?: long(name='CompanyId'),
          gmtCreate?: string(name='GmtCreate'),
          gmtModified?: string(name='GmtModified'),
          id?: long(name='Id'),
          name?: string(name='Name'),
          parentId?: long(name='ParentId'),
          status?: string(name='Status'),
          type?: string(name='Type'),
        }
      ](name='Roles'),
      status?: string(name='Status'),
    }
  ](name='Content'),
  empty?: boolean(name='Empty'),
  first?: boolean(name='First'),
  last?: boolean(name='Last'),
  number?: long(name='Number'),
  numberOfElements?: long(name='NumberOfElements'),
  pageable?: {
    offset?: long(name='Offset'),
    pageNumber?: long(name='PageNumber'),
    pageSize?: long(name='PageSize'),
    paged?: boolean(name='Paged'),
    sort?: {
      empty?: boolean(name='Empty'),
      sorted?: boolean(name='Sorted'),
      unsorted?: boolean(name='Unsorted'),
    }(name='Sort'),
    unpaged?: boolean(name='Unpaged'),
  }(name='Pageable'),
  requestId?: string(name='RequestId', description='Id of the request'),
  size?: long(name='Size'),
  sort?: {
    empty?: boolean(name='Empty'),
    sorted?: boolean(name='Sorted'),
    unsorted?: boolean(name='Unsorted'),
  }(name='Sort'),
  totalElements?: long(name='TotalElements'),
  totalPages?: long(name='TotalPages'),
}

model UserFindAllResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UserFindAllResponseBody(name='body'),
}

async function userFindAllWithOptions(request: UserFindAllRequest, runtime: Util.RuntimeOptions): UserFindAllResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UserFindAll',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function userFindAll(request: UserFindAllRequest): UserFindAllResponse {
  var runtime = new Util.RuntimeOptions{};
  return userFindAllWithOptions(request, runtime);
}

model UserFindByRolesRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  roleNames?: string(name='RoleNames'),
}

model UserFindByRolesResponseBody = {
  data?: [ 
    {
      email?: string(name='Email'),
      ext1?: string(name='Ext1'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      phone?: string(name='Phone'),
      status?: string(name='Status'),
    }
  ](name='Data'),
  requestId?: string(name='RequestId'),
}

model UserFindByRolesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UserFindByRolesResponseBody(name='body'),
}

async function userFindByRolesWithOptions(request: UserFindByRolesRequest, runtime: Util.RuntimeOptions): UserFindByRolesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.roleNames)) {
    query['RoleNames'] = request.roleNames;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UserFindByRoles',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function userFindByRoles(request: UserFindByRolesRequest): UserFindByRolesResponse {
  var runtime = new Util.RuntimeOptions{};
  return userFindByRolesWithOptions(request, runtime);
}

model UserGetOneRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  userId?: long(name='UserId'),
}

model UserGetOneResponseBody = {
  aliyunAccount?: string(name='AliyunAccount'),
  aliyunUid?: string(name='AliyunUid'),
  aliyunUidType?: string(name='AliyunUidType'),
  companyId?: long(name='CompanyId'),
  companyName?: string(name='CompanyName'),
  email?: string(name='Email'),
  ext1?: string(name='Ext1'),
  gmtCreate?: string(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  name?: string(name='Name'),
  parentUid?: string(name='ParentUid'),
  phone?: string(name='Phone'),
  requestId?: string(name='RequestId', description='Id of the request'),
  roles?: [ 
    {
      code?: string(name='Code'),
      companyId?: long(name='CompanyId'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      parentId?: long(name='ParentId'),
      status?: string(name='Status'),
      type?: string(name='Type'),
    }
  ](name='Roles'),
  status?: string(name='Status'),
}

model UserGetOneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UserGetOneResponseBody(name='body'),
}

async function userGetOneWithOptions(request: UserGetOneRequest, runtime: Util.RuntimeOptions): UserGetOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.userId)) {
    query['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UserGetOne',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function userGetOne(request: UserGetOneRequest): UserGetOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return userGetOneWithOptions(request, runtime);
}

model UserListMenusRequest {
  aliyunJwt?: string(name='AliyunJwt'),
}

model UserListMenusResponseBody = {
  data?: [ 
    {
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      status?: string(name='Status'),
      url?: string(name='Url'),
    }
  ](name='Data'),
  requestId?: string(name='RequestId'),
}

model UserListMenusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UserListMenusResponseBody(name='body'),
}

async function userListMenusWithOptions(request: UserListMenusRequest, runtime: Util.RuntimeOptions): UserListMenusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UserListMenus',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function userListMenus(request: UserListMenusRequest): UserListMenusResponse {
  var runtime = new Util.RuntimeOptions{};
  return userListMenusWithOptions(request, runtime);
}

model UserListPermissionsRequest {
  aliyunJwt?: string(name='AliyunJwt'),
}

model UserListPermissionsResponseBody = {
  data?: [ 
    {
      companyId?: long(name='CompanyId'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      status?: string(name='Status'),
      type?: string(name='Type'),
    }
  ](name='Data'),
  requestId?: string(name='RequestId'),
}

model UserListPermissionsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UserListPermissionsResponseBody(name='body'),
}

async function userListPermissionsWithOptions(request: UserListPermissionsRequest, runtime: Util.RuntimeOptions): UserListPermissionsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UserListPermissions',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function userListPermissions(request: UserListPermissionsRequest): UserListPermissionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return userListPermissionsWithOptions(request, runtime);
}

model UserListRolesRequest {
  aliyunJwt?: string(name='AliyunJwt'),
}

model UserListRolesResponseBody = {
  data?: [ 
    {
      code?: string(name='Code'),
      companyId?: long(name='CompanyId'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      parentId?: long(name='ParentId'),
      status?: string(name='Status'),
      type?: string(name='Type'),
    }
  ](name='Data'),
  requestId?: string(name='RequestId'),
}

model UserListRolesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UserListRolesResponseBody(name='body'),
}

async function userListRolesWithOptions(request: UserListRolesRequest, runtime: Util.RuntimeOptions): UserListRolesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UserListRoles',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function userListRoles(request: UserListRolesRequest): UserListRolesResponse {
  var runtime = new Util.RuntimeOptions{};
  return userListRolesWithOptions(request, runtime);
}

model UserListSubRolesRequest {
  aliyunJwt?: string(name='AliyunJwt'),
}

model UserListSubRolesResponseBody = {
  data?: [ 
    {
      code?: string(name='Code'),
      companyId?: long(name='CompanyId'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      parentId?: long(name='ParentId'),
      status?: string(name='Status'),
      type?: string(name='Type'),
    }
  ](name='Data'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model UserListSubRolesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UserListSubRolesResponseBody(name='body'),
}

async function userListSubRolesWithOptions(request: UserListSubRolesRequest, runtime: Util.RuntimeOptions): UserListSubRolesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UserListSubRoles',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function userListSubRoles(request: UserListSubRolesRequest): UserListSubRolesResponse {
  var runtime = new Util.RuntimeOptions{};
  return userListSubRolesWithOptions(request, runtime);
}

model UserQueryCreatePermissionRequest {
  jwt?: string(name='Jwt'),
}

model UserQueryCreatePermissionResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  result?: map[string]any(name='Result', description='对象实例。'),
}

model UserQueryCreatePermissionResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UserQueryCreatePermissionResponseBody(name='body'),
}

async function userQueryCreatePermissionWithOptions(request: UserQueryCreatePermissionRequest, runtime: Util.RuntimeOptions): UserQueryCreatePermissionResponse {
  Util.validateModel(request);
  var body : map[string]any= {};
  if (!Util.isUnset(request.jwt)) {
    body['Jwt'] = request.jwt;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UserQueryCreatePermission',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function userQueryCreatePermission(request: UserQueryCreatePermissionRequest): UserQueryCreatePermissionResponse {
  var runtime = new Util.RuntimeOptions{};
  return userQueryCreatePermissionWithOptions(request, runtime);
}

model ValidAliyunUidRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  aliyunUid?: string(name='AliyunUid'),
}

model ValidAliyunUidResponseBody = {
  isValid?: string(name='IsValid'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model ValidAliyunUidResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ValidAliyunUidResponseBody(name='body'),
}

async function validAliyunUidWithOptions(request: ValidAliyunUidRequest, runtime: Util.RuntimeOptions): ValidAliyunUidResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.aliyunUid)) {
    query['AliyunUid'] = request.aliyunUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ValidAliyunUid',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function validAliyunUid(request: ValidAliyunUidRequest): ValidAliyunUidResponse {
  var runtime = new Util.RuntimeOptions{};
  return validAliyunUidWithOptions(request, runtime);
}

model ValidCompanyNameRequest {
  aliyunJwt?: string(name='AliyunJwt'),
  companyName?: string(name='CompanyName'),
}

model ValidCompanyNameResponseBody = {
  isValid?: string(name='IsValid'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId', description='Id of the request'),
}

model ValidCompanyNameResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ValidCompanyNameResponseBody(name='body'),
}

async function validCompanyNameWithOptions(request: ValidCompanyNameRequest, runtime: Util.RuntimeOptions): ValidCompanyNameResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliyunJwt)) {
    query['AliyunJwt'] = request.aliyunJwt;
  }
  if (!Util.isUnset(request.companyName)) {
    query['CompanyName'] = request.companyName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ValidCompanyName',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function validCompanyName(request: ValidCompanyNameRequest): ValidCompanyNameResponse {
  var runtime = new Util.RuntimeOptions{};
  return validCompanyNameWithOptions(request, runtime);
}

model VrUserCreateScanUserRequest {
  bizOrderNo?: string(name='BizOrderNo', description='业务幂等ID，用于防止重复请求，写操作必传'),
  phoneNum?: string(name='PhoneNum', description='用户需要创建扫描权限账号的手机号码'),
  source?: string(name='Source', description='数据源，目前只有3VJIA，需要新增请联系接口owner'),
}

model VrUserCreateScanUserResponseBody = {
  async?: boolean(name='Async', description='async'),
  asyncToken?: string(name='AsyncToken', description='asyncToken'),
  errorCode?: string(name='ErrorCode', description='errorCode'),
  errorMsg?: string(name='ErrorMsg', description='errorMsg'),
  requestId?: string(name='RequestId', description='traceId'),
  resultObj?: map[string]any(name='ResultObj', description='resultObj'),
  retry?: boolean(name='Retry', description='retry'),
  success?: boolean(name='Success', description='success'),
}

model VrUserCreateScanUserResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: VrUserCreateScanUserResponseBody(name='body'),
}

async function vrUserCreateScanUserWithOptions(request: VrUserCreateScanUserRequest, runtime: Util.RuntimeOptions): VrUserCreateScanUserResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizOrderNo)) {
    query['BizOrderNo'] = request.bizOrderNo;
  }
  if (!Util.isUnset(request.phoneNum)) {
    query['PhoneNum'] = request.phoneNum;
  }
  if (!Util.isUnset(request.source)) {
    query['Source'] = request.source;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'VrUserCreateScanUser',
    version = '2020-07-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function vrUserCreateScanUser(request: VrUserCreateScanUserRequest): VrUserCreateScanUserResponse {
  var runtime = new Util.RuntimeOptions{};
  return vrUserCreateScanUserWithOptions(request, runtime);
}

